dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/style-change.h>
 437 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 438 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 455 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 456 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 457
 458 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 459 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 460 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 461
 462 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 464 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 465
 466 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 467
 468 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 469
 470
 471
 472 // add here SWIG version check
 473
 474 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 475 // disable Swig-dependent warnings
 476
 477 // 'identifier1' has C-linkage specified,
 478 // but returns UDT 'identifier2' which is incompatible with C
 479 #pragma warning(disable: 4190)
 480
 481 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 482 #pragma warning(disable: 4800)
 483
 484 // debug info too long etc etc
 485 #pragma warning(disable: 4786)
 486 #endif
 487
 488
 489 #include <stdexcept>
 490
 491
 492 #include <string>
 493
 494
 495 #include <vector>
 496 #include <algorithm>
 497 #include <stdexcept>
 498
 499
 500 #include <map>
 501 #include <algorithm>
 502 #include <stdexcept>
 503
 504
 505 #include <utility>
 506
 507
 508 typedef float floatp;
 509
 510 SWIGINTERN floatp *new_floatp(){
 511   return new float();
 512 }
 513 SWIGINTERN void delete_floatp(floatp *self){
 514   if (self) delete self;
 515 }
 516 SWIGINTERN void floatp_assign(floatp *self,float value){
 517   *self = value;
 518 }
 519 SWIGINTERN float floatp_value(floatp *self){
 520   return *self;
 521 }
 522 SWIGINTERN float *floatp_cast(floatp *self){
 523   return self;
 524 }
 525 SWIGINTERN floatp *floatp_frompointer(float *t){
 526   return (floatp *) t;
 527 }
 528
 529 typedef int intp;
 530
 531 SWIGINTERN intp *new_intp(){
 532   return new int();
 533 }
 534 SWIGINTERN void delete_intp(intp *self){
 535   if (self) delete self;
 536 }
 537 SWIGINTERN void intp_assign(intp *self,int value){
 538   *self = value;
 539 }
 540 SWIGINTERN int intp_value(intp *self){
 541   return *self;
 542 }
 543 SWIGINTERN int *intp_cast(intp *self){
 544   return self;
 545 }
 546 SWIGINTERN intp *intp_frompointer(int *t){
 547   return (intp *) t;
 548 }
 549
 550 typedef double doublep;
 551
 552 SWIGINTERN doublep *new_doublep(){
 553   return new double();
 554 }
 555 SWIGINTERN void delete_doublep(doublep *self){
 556   if (self) delete self;
 557 }
 558 SWIGINTERN void doublep_assign(doublep *self,double value){
 559   *self = value;
 560 }
 561 SWIGINTERN double doublep_value(doublep *self){
 562   return *self;
 563 }
 564 SWIGINTERN double *doublep_cast(doublep *self){
 565   return self;
 566 }
 567 SWIGINTERN doublep *doublep_frompointer(double *t){
 568   return (doublep *) t;
 569 }
 570
 571 typedef unsigned int uintp;
 572
 573 SWIGINTERN uintp *new_uintp(){
 574   return new unsigned int();
 575 }
 576 SWIGINTERN void delete_uintp(uintp *self){
 577   if (self) delete self;
 578 }
 579 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 580   *self = value;
 581 }
 582 SWIGINTERN unsigned int uintp_value(uintp *self){
 583   return *self;
 584 }
 585 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 586   return self;
 587 }
 588 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 589   return (uintp *) t;
 590 }
 591
 592 typedef unsigned short ushortp;
 593
 594 SWIGINTERN ushortp *new_ushortp(){
 595   return new unsigned short();
 596 }
 597 SWIGINTERN void delete_ushortp(ushortp *self){
 598   if (self) delete self;
 599 }
 600 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 601   *self = value;
 602 }
 603 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 604   return *self;
 605 }
 606 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 607   return self;
 608 }
 609 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 610   return (ushortp *) t;
 611 }
 612
 613 unsigned int int_to_uint(int x) {
 614    return (unsigned int) x;
 615 }
 616
 617
 618 using namespace Dali;
 619 using namespace Dali::Toolkit;
 620
 621 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 622
 623      // C++ code. DALi uses Handle <-> Body design pattern.
 624      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 625      // Handles in DALi can be converted into a boolean type
 626      // to check if the handle has a valid body attached to it.
 627      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 628      if( *self )
 629      {
 630        return true;
 631      }
 632      else
 633      {
 634        return false;
 635      }
 636     }
 637 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 638
 639      // C++ code. Check if two handles reference the same implemtion
 640      if( *self == rhs)
 641      {
 642        return true;
 643      }
 644      else
 645      {
 646        return false;
 647      }
 648     }
 649 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 650      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 651    }
 652 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){
 653      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 654    }
 655 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 656         std::vector< Dali::TouchPoint >* pv = 0;
 657         if (capacity >= 0) {
 658           pv = new std::vector< Dali::TouchPoint >();
 659           pv->reserve(capacity);
 660        } else {
 661           throw std::out_of_range("capacity");
 662        }
 663        return pv;
 664       }
 665 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 666         if (index>=0 && index<(int)self->size())
 667           return (*self)[index];
 668         else
 669           throw std::out_of_range("index");
 670       }
 671 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 672         if (index>=0 && index<(int)self->size())
 673           return (*self)[index];
 674         else
 675           throw std::out_of_range("index");
 676       }
 677 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 678         if (index>=0 && index<(int)self->size())
 679           (*self)[index] = val;
 680         else
 681           throw std::out_of_range("index");
 682       }
 683 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 684         self->insert(self->end(), values.begin(), values.end());
 685       }
 686 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 687         if (index < 0)
 688           throw std::out_of_range("index");
 689         if (count < 0)
 690           throw std::out_of_range("count");
 691         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 692           throw std::invalid_argument("invalid range");
 693         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 694       }
 695 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 696         if (index>=0 && index<(int)self->size()+1)
 697           self->insert(self->begin()+index, x);
 698         else
 699           throw std::out_of_range("index");
 700       }
 701 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 702         if (index>=0 && index<(int)self->size()+1)
 703           self->insert(self->begin()+index, values.begin(), values.end());
 704         else
 705           throw std::out_of_range("index");
 706       }
 707 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 708         if (index>=0 && index<(int)self->size())
 709           self->erase(self->begin() + index);
 710         else
 711           throw std::out_of_range("index");
 712       }
 713 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 714         if (index < 0)
 715           throw std::out_of_range("index");
 716         if (count < 0)
 717           throw std::out_of_range("count");
 718         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 719           throw std::invalid_argument("invalid range");
 720         self->erase(self->begin()+index, self->begin()+index+count);
 721       }
 722 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 723         if (count < 0)
 724           throw std::out_of_range("count");
 725         return new std::vector< Dali::TouchPoint >(count, value);
 726       }
 727 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 728         std::reverse(self->begin(), self->end());
 729       }
 730 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 731         if (index < 0)
 732           throw std::out_of_range("index");
 733         if (count < 0)
 734           throw std::out_of_range("count");
 735         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 736           throw std::invalid_argument("invalid range");
 737         std::reverse(self->begin()+index, self->begin()+index+count);
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 740         if (index < 0)
 741           throw std::out_of_range("index");
 742         if (index+values.size() > self->size())
 743           throw std::out_of_range("index");
 744         std::copy(values.begin(), values.end(), self->begin()+index);
 745       }
 746 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 747          return self->Empty();
 748       }
 749 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 750         return self->GetConnectionCount();
 751       }
 752 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 753           self->Connect( func );
 754       }
 755 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 756           self->Disconnect( func );
 757       }
 758 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 759           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 760 /*@SWIG@*/ self->Emit( arg );
 761       }
 762 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 763          return self->Empty();
 764       }
 765 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 766         return self->GetConnectionCount();
 767       }
 768 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 769           self->Connect( func );
 770       }
 771 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 772           self->Disconnect( func );
 773       }
 774 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 775           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 776 /*@SWIG@*/ self->Emit( arg );
 777       }
 778 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 779          return self->Empty();
 780       }
 781 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){
 782         return self->GetConnectionCount();
 783       }
 784 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 *)){
 785           self->Connect( func );
 786       }
 787 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 *)){
 788           self->Disconnect( func );
 789       }
 790 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){
 791           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 792 /*@SWIG@*/ self->Emit( arg );
 793       }
 794 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 795          return self->Empty();
 796       }
 797 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 798         return self->GetConnectionCount();
 799       }
 800 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 801           self->Connect( func );
 802       }
 803 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 804           self->Disconnect( func );
 805       }
 806 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 807           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 808 /*@SWIG@*/ self->Emit( arg );
 809       }
 810 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 811          return self->Empty();
 812       }
 813 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 814         return self->GetConnectionCount();
 815       }
 816 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 817           self->Connect( func );
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 820           self->Disconnect( func );
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 823           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 824 /*@SWIG@*/ self->Emit( arg );
 825       }
 826 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){
 827          return self->Empty();
 828       }
 829 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){
 830         return self->GetConnectionCount();
 831       }
 832 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 &)){
 833         self->Connect( func );
 834       }
 835 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 &)){
 836         self->Disconnect( func );
 837       }
 838 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){
 839         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 840 /*@SWIG@*/ self->Emit( arg1, arg2 );
 841       }
 842 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){
 843          return self->Empty();
 844       }
 845 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){
 846         return self->GetConnectionCount();
 847       }
 848 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 &)){
 849         self->Connect( func );
 850       }
 851 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 &)){
 852         self->Disconnect( func );
 853       }
 854 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){
 855         return self->Emit( arg1, arg2 );
 856       }
 857 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){
 858          return self->Empty();
 859       }
 860 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){
 861         return self->GetConnectionCount();
 862       }
 863 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 &)){
 864         self->Connect( func );
 865       }
 866 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 &)){
 867         self->Disconnect( func );
 868       }
 869 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){
 870         return self->Emit( arg1, arg2 );
 871       }
 872 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){
 873          return self->Empty();
 874       }
 875 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){
 876         return self->GetConnectionCount();
 877       }
 878 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 &)){
 879         self->Connect( func );
 880       }
 881 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 &)){
 882         self->Disconnect( func );
 883       }
 884 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){
 885         return self->Emit( arg1, arg2 );
 886       }
 887 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 888          return self->Empty();
 889       }
 890 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 891         return self->GetConnectionCount();
 892       }
 893 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 894           self->Connect( func );
 895       }
 896 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 897           self->Disconnect( func );
 898       }
 899 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 900           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 901 /*@SWIG@*/ self->Emit( arg );
 902       }
 903 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 904          return self->Empty();
 905       }
 906 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){
 907         return self->GetConnectionCount();
 908       }
 909 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 &)){
 910           self->Connect( func );
 911       }
 912 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 &)){
 913           self->Disconnect( func );
 914       }
 915 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){
 916           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 917 /*@SWIG@*/ self->Emit( arg );
 918       }
 919 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 920          return self->Empty();
 921       }
 922 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){
 923         return self->GetConnectionCount();
 924       }
 925 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 &)){
 926           self->Connect( func );
 927       }
 928 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 &)){
 929           self->Disconnect( func );
 930       }
 931 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){
 932           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 933 /*@SWIG@*/ self->Emit( arg );
 934       }
 935 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 936          return self->Empty();
 937       }
 938 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){
 939         return self->GetConnectionCount();
 940       }
 941 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 &)){
 942           self->Connect( func );
 943       }
 944 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 &)){
 945           self->Disconnect( func );
 946       }
 947 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){
 948           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 949 /*@SWIG@*/ self->Emit( arg );
 950       }
 951 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){
 952          return self->Empty();
 953       }
 954 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){
 955         return self->GetConnectionCount();
 956       }
 957 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 &)){
 958         self->Connect( func );
 959       }
 960 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 &)){
 961         self->Disconnect( func );
 962       }
 963 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){
 964         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 965 /*@SWIG@*/ self->Emit( arg1, arg2 );
 966       }
 967 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){
 968          return self->Empty();
 969       }
 970 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){
 971         return self->GetConnectionCount();
 972       }
 973 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 &)){
 974         self->Connect( func );
 975       }
 976 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 &)){
 977         self->Disconnect( func );
 978       }
 979 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){
 980         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 981 /*@SWIG@*/ self->Emit( arg1, arg2 );
 982       }
 983 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){
 984          return self->Empty();
 985       }
 986 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){
 987         return self->GetConnectionCount();
 988       }
 989 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 &)){
 990         self->Connect( func );
 991       }
 992 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 &)){
 993         self->Disconnect( func );
 994       }
 995 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){
 996         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 997 /*@SWIG@*/ self->Emit( arg1, arg2 );
 998       }
 999 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1000          return self->Empty();
1001       }
1002 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1003         return self->GetConnectionCount();
1004       }
1005 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1006           self->Connect( func );
1007       }
1008 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1009           self->Disconnect( func );
1010       }
1011 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1012           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1013 /*@SWIG@*/ self->Emit( arg );
1014       }
1015 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){
1016          return self->Empty();
1017       }
1018 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){
1019         return self->GetConnectionCount();
1020       }
1021 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)){
1022           return self->Connect( func );
1023       }
1024 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)){
1025           self->Disconnect( func );
1026       }
1027 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){
1028           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1029 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1030       }
1031
1032 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1033          return self->Empty();
1034       }
1035 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1036         return self->GetConnectionCount();
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1039           self->Connect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1042           self->Disconnect( func );
1043       }
1044 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1045           return self->Emit();
1046       }
1047
1048 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1049         std::vector< unsigned int >* pv = 0;
1050         if (capacity >= 0) {
1051           pv = new std::vector< unsigned int >();
1052           pv->reserve(capacity);
1053        } else {
1054           throw std::out_of_range("capacity");
1055        }
1056        return pv;
1057       }
1058 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1059         if (index>=0 && index<(int)self->size())
1060           return (*self)[index];
1061         else
1062           throw std::out_of_range("index");
1063       }
1064 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1065         if (index>=0 && index<(int)self->size())
1066           return (*self)[index];
1067         else
1068           throw std::out_of_range("index");
1069       }
1070 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1071         if (index>=0 && index<(int)self->size())
1072           (*self)[index] = val;
1073         else
1074           throw std::out_of_range("index");
1075       }
1076 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1077         self->insert(self->end(), values.begin(), values.end());
1078       }
1079 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1080         if (index < 0)
1081           throw std::out_of_range("index");
1082         if (count < 0)
1083           throw std::out_of_range("count");
1084         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1085           throw std::invalid_argument("invalid range");
1086         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1087       }
1088 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1089         if (index>=0 && index<(int)self->size()+1)
1090           self->insert(self->begin()+index, x);
1091         else
1092           throw std::out_of_range("index");
1093       }
1094 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1095         if (index>=0 && index<(int)self->size()+1)
1096           self->insert(self->begin()+index, values.begin(), values.end());
1097         else
1098           throw std::out_of_range("index");
1099       }
1100 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1101         if (index>=0 && index<(int)self->size())
1102           self->erase(self->begin() + index);
1103         else
1104           throw std::out_of_range("index");
1105       }
1106 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1107         if (index < 0)
1108           throw std::out_of_range("index");
1109         if (count < 0)
1110           throw std::out_of_range("count");
1111         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1112           throw std::invalid_argument("invalid range");
1113         self->erase(self->begin()+index, self->begin()+index+count);
1114       }
1115 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1116         if (count < 0)
1117           throw std::out_of_range("count");
1118         return new std::vector< unsigned int >(count, value);
1119       }
1120 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1121         std::reverse(self->begin(), self->end());
1122       }
1123 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(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         std::reverse(self->begin()+index, self->begin()+index+count);
1131       }
1132 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1133         if (index < 0)
1134           throw std::out_of_range("index");
1135         if (index+values.size() > self->size())
1136           throw std::out_of_range("index");
1137         std::copy(values.begin(), values.end(), self->begin()+index);
1138       }
1139 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1140         return std::find(self->begin(), self->end(), value) != self->end();
1141       }
1142 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1143         int index = -1;
1144         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1145         if (it != self->end())
1146           index = (int)(it - self->begin());
1147         return index;
1148       }
1149 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1150         int index = -1;
1151         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1152         if (rit != self->rend())
1153           index = (int)(self->rend() - 1 - rit);
1154         return index;
1155       }
1156 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1157         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1158         if (it != self->end()) {
1159           self->erase(it);
1160           return true;
1161         }
1162         return false;
1163       }
1164 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){
1165         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1166         if (capacity >= 0) {
1167           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1168           pv->reserve(capacity);
1169        } else {
1170           throw std::out_of_range("capacity");
1171        }
1172        return pv;
1173       }
1174 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){
1175         if (index>=0 && index<(int)self->size())
1176           return (*self)[index];
1177         else
1178           throw std::out_of_range("index");
1179       }
1180 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){
1181         if (index>=0 && index<(int)self->size())
1182           return (*self)[index];
1183         else
1184           throw std::out_of_range("index");
1185       }
1186 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){
1187         if (index>=0 && index<(int)self->size())
1188           (*self)[index] = val;
1189         else
1190           throw std::out_of_range("index");
1191       }
1192 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){
1193         self->insert(self->end(), values.begin(), values.end());
1194       }
1195 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){
1196         if (index < 0)
1197           throw std::out_of_range("index");
1198         if (count < 0)
1199           throw std::out_of_range("count");
1200         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1201           throw std::invalid_argument("invalid range");
1202         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1203       }
1204 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){
1205         if (index>=0 && index<(int)self->size()+1)
1206           self->insert(self->begin()+index, x);
1207         else
1208           throw std::out_of_range("index");
1209       }
1210 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){
1211         if (index>=0 && index<(int)self->size()+1)
1212           self->insert(self->begin()+index, values.begin(), values.end());
1213         else
1214           throw std::out_of_range("index");
1215       }
1216 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){
1217         if (index>=0 && index<(int)self->size())
1218           self->erase(self->begin() + index);
1219         else
1220           throw std::out_of_range("index");
1221       }
1222 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){
1223         if (index < 0)
1224           throw std::out_of_range("index");
1225         if (count < 0)
1226           throw std::out_of_range("count");
1227         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1228           throw std::invalid_argument("invalid range");
1229         self->erase(self->begin()+index, self->begin()+index+count);
1230       }
1231 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){
1232         if (count < 0)
1233           throw std::out_of_range("count");
1234         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1235       }
1236 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){
1237         std::reverse(self->begin(), self->end());
1238       }
1239 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){
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         std::reverse(self->begin()+index, self->begin()+index+count);
1247       }
1248 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){
1249         if (index < 0)
1250           throw std::out_of_range("index");
1251         if (index+values.size() > self->size())
1252           throw std::out_of_range("index");
1253         std::copy(values.begin(), values.end(), self->begin()+index);
1254       }
1255 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1256         std::vector< Dali::Actor >* pv = 0;
1257         if (capacity >= 0) {
1258           pv = new std::vector< Dali::Actor >();
1259           pv->reserve(capacity);
1260        } else {
1261           throw std::out_of_range("capacity");
1262        }
1263        return pv;
1264       }
1265 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1266         if (index>=0 && index<(int)self->size())
1267           return (*self)[index];
1268         else
1269           throw std::out_of_range("index");
1270       }
1271 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1272         if (index>=0 && index<(int)self->size())
1273           return (*self)[index];
1274         else
1275           throw std::out_of_range("index");
1276       }
1277 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1278         if (index>=0 && index<(int)self->size())
1279           (*self)[index] = val;
1280         else
1281           throw std::out_of_range("index");
1282       }
1283 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1284         self->insert(self->end(), values.begin(), values.end());
1285       }
1286 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1287         if (index < 0)
1288           throw std::out_of_range("index");
1289         if (count < 0)
1290           throw std::out_of_range("count");
1291         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1292           throw std::invalid_argument("invalid range");
1293         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1294       }
1295 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1296         if (index>=0 && index<(int)self->size()+1)
1297           self->insert(self->begin()+index, x);
1298         else
1299           throw std::out_of_range("index");
1300       }
1301 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1302         if (index>=0 && index<(int)self->size()+1)
1303           self->insert(self->begin()+index, values.begin(), values.end());
1304         else
1305           throw std::out_of_range("index");
1306       }
1307 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1308         if (index>=0 && index<(int)self->size())
1309           self->erase(self->begin() + index);
1310         else
1311           throw std::out_of_range("index");
1312       }
1313 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1314         if (index < 0)
1315           throw std::out_of_range("index");
1316         if (count < 0)
1317           throw std::out_of_range("count");
1318         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1319           throw std::invalid_argument("invalid range");
1320         self->erase(self->begin()+index, self->begin()+index+count);
1321       }
1322 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1323         if (count < 0)
1324           throw std::out_of_range("count");
1325         return new std::vector< Dali::Actor >(count, value);
1326       }
1327 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1328         std::reverse(self->begin(), self->end());
1329       }
1330 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(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         std::reverse(self->begin()+index, self->begin()+index+count);
1338       }
1339 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1340         if (index < 0)
1341           throw std::out_of_range("index");
1342         if (index+values.size() > self->size())
1343           throw std::out_of_range("index");
1344         std::copy(values.begin(), values.end(), self->begin()+index);
1345       }
1346 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1347          return self->Empty();
1348       }
1349 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1350         return self->GetConnectionCount();
1351       }
1352 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 &)){
1353           self->Connect( func );
1354       }
1355 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 &)){
1356           self->Disconnect( func );
1357       }
1358 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){
1359           return self->Emit( arg );
1360       }
1361 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){
1362          return self->Empty();
1363       }
1364 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){
1365         return self->GetConnectionCount();
1366       }
1367 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)){
1368         self->Connect( func );
1369       }
1370 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)){
1371         self->Disconnect( func );
1372       }
1373 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){
1374         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1375 /*@SWIG@*/ self->Emit( arg1, arg2 );
1376       }
1377 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1378          return self->Empty();
1379       }
1380 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){
1381         return self->GetConnectionCount();
1382       }
1383 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)){
1384         self->Connect( func );
1385       }
1386 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)){
1387         self->Disconnect( func );
1388       }
1389 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){
1390         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1391 /*@SWIG@*/ self->Emit( arg1, arg2 );
1392       }
1393 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1394          return self->Empty();
1395       }
1396 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1397         return self->GetConnectionCount();
1398       }
1399 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)){
1400         self->Connect( func );
1401       }
1402 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)){
1403         self->Disconnect( func );
1404       }
1405 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){
1406         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1407 /*@SWIG@*/ self->Emit( arg1, arg2 );
1408       }
1409 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){
1410          return self->Empty();
1411       }
1412 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){
1413         return self->GetConnectionCount();
1414       }
1415 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)){
1416         self->Connect( func );
1417       }
1418 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)){
1419         self->Disconnect( func );
1420       }
1421 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){
1422         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1423 /*@SWIG@*/ self->Emit( arg1, arg2 );
1424       }
1425 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1426          return self->Empty();
1427       }
1428 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1429         return self->GetConnectionCount();
1430       }
1431 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)){
1432           self->Connect( func );
1433       }
1434 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)){
1435           self->Disconnect( func );
1436       }
1437 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1438           return self->Emit( arg );
1439       }
1440 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1441          return self->Empty();
1442       }
1443 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1444         return self->GetConnectionCount();
1445       }
1446 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)){
1447           self->Connect( func );
1448       }
1449 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)){
1450           self->Disconnect( func );
1451       }
1452 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1453           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1454 /*@SWIG@*/ self->Emit( arg );
1455       }
1456 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){
1457          return self->Empty();
1458       }
1459 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){
1460         return self->GetConnectionCount();
1461       }
1462 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)){
1463           return self->Connect( func );
1464       }
1465 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)){
1466           self->Disconnect( func );
1467       }
1468 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){
1469           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1470 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1471       }
1472 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1473          return self->Empty();
1474       }
1475 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1476         return self->GetConnectionCount();
1477       }
1478 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)){
1479           self->Connect( func );
1480       }
1481 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)){
1482           self->Disconnect( func );
1483       }
1484 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1485           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1486 /*@SWIG@*/ self->Emit( arg );
1487       }
1488 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){
1489          return self->Empty();
1490       }
1491 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){
1492         return self->GetConnectionCount();
1493       }
1494 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)){
1495           return self->Connect( func );
1496       }
1497 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)){
1498           self->Disconnect( func );
1499       }
1500 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){
1501           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1502 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1503       }
1504 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){
1505          return self->Empty();
1506       }
1507 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){
1508         return self->GetConnectionCount();
1509       }
1510 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 &)){
1511           self->Connect( func );
1512       }
1513 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 &)){
1514           self->Disconnect( func );
1515       }
1516 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){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg );
1519       }
1520 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1521          return self->Empty();
1522       }
1523 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){
1524         return self->GetConnectionCount();
1525       }
1526 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 &)){
1527           self->Connect( func );
1528       }
1529 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 &)){
1530           self->Disconnect( func );
1531       }
1532 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){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg );
1535       }
1536
1537
1538 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){
1539          return self->Empty();
1540       }
1541 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){
1542         return self->GetConnectionCount();
1543       }
1544 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 &)){
1545         self->Connect( func );
1546       }
1547 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 &)){
1548         self->Disconnect( func );
1549       }
1550 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){
1551         return self->Emit( arg1, arg2 );
1552       }
1553 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1554          return self->Empty();
1555       }
1556 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1557         return self->GetConnectionCount();
1558       }
1559 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)){
1560           self->Connect( func );
1561       }
1562 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)){
1563           self->Disconnect( func );
1564       }
1565 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1566           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1567 /*@SWIG@*/ self->Emit( arg );
1568       }
1569 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1570          return self->Empty();
1571       }
1572 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1573         return self->GetConnectionCount();
1574       }
1575 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 &)){
1576           self->Connect( func );
1577       }
1578 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 &)){
1579           self->Disconnect( func );
1580       }
1581 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){
1582           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1583 /*@SWIG@*/ self->Emit( arg );
1584       }
1585 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1586          return self->Empty();
1587       }
1588 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){
1589         return self->GetConnectionCount();
1590       }
1591 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)){
1592         self->Connect( func );
1593       }
1594 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)){
1595         self->Disconnect( func );
1596       }
1597 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){
1598         return self->Emit( arg1, arg2 );
1599       }
1600 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1601          return self->Empty();
1602       }
1603 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){
1604         return self->GetConnectionCount();
1605       }
1606 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)){
1607         self->Connect( func );
1608       }
1609 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)){
1610         self->Disconnect( func );
1611       }
1612 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){
1613         return self->Emit( arg1, arg2 );
1614       }
1615
1616
1617 /* ---------------------------------------------------
1618  * C++ director class methods
1619  * --------------------------------------------------- */
1620
1621 #include "dali_wrap.h"
1622
1623 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1624   swig_init_callbacks();
1625 }
1626
1627 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1628
1629 }
1630
1631
1632 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1633   int jdepth  ;
1634
1635   if (!swig_callbackOnStageConnection) {
1636     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1637     return;
1638   } else {
1639     jdepth = depth;
1640     swig_callbackOnStageConnection(jdepth);
1641   }
1642 }
1643
1644 void SwigDirector_ViewImpl::OnStageDisconnection() {
1645   if (!swig_callbackOnStageDisconnection) {
1646     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1647     return;
1648   } else {
1649     swig_callbackOnStageDisconnection();
1650   }
1651 }
1652
1653 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1654   void * jchild = 0 ;
1655
1656   if (!swig_callbackOnChildAdd) {
1657     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1658     return;
1659   } else {
1660     jchild = (Dali::Actor *) &child;
1661     swig_callbackOnChildAdd(jchild);
1662   }
1663 }
1664
1665 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1666   void * jchild = 0 ;
1667
1668   if (!swig_callbackOnChildRemove) {
1669     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1670     return;
1671   } else {
1672     jchild = (Dali::Actor *) &child;
1673     swig_callbackOnChildRemove(jchild);
1674   }
1675 }
1676
1677 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1678   int jindex  ;
1679   void * jpropertyValue  ;
1680
1681   if (!swig_callbackOnPropertySet) {
1682     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1683     return;
1684   } else {
1685     jindex = index;
1686     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1687     swig_callbackOnPropertySet(jindex, jpropertyValue);
1688   }
1689 }
1690
1691 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1692   void * jtargetSize = 0 ;
1693
1694   if (!swig_callbackOnSizeSet) {
1695     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1696     return;
1697   } else {
1698     jtargetSize = (Dali::Vector3 *) &targetSize;
1699     swig_callbackOnSizeSet(jtargetSize);
1700   }
1701 }
1702
1703 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1704   void * janimation = 0 ;
1705   void * jtargetSize = 0 ;
1706
1707   if (!swig_callbackOnSizeAnimation) {
1708     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1709     return;
1710   } else {
1711     janimation = (Dali::Animation *) &animation;
1712     jtargetSize = (Dali::Vector3 *) &targetSize;
1713     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1714   }
1715 }
1716
1717 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1718   bool c_result = SwigValueInit< bool >() ;
1719   unsigned int jresult = 0 ;
1720   void * jarg0 = 0 ;
1721
1722   if (!swig_callbackOnTouchEvent) {
1723     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1724   } else {
1725     jarg0 = (Dali::TouchEvent *) &event;
1726     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1727     c_result = jresult ? true : false;
1728   }
1729   return c_result;
1730 }
1731
1732 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1733   bool c_result = SwigValueInit< bool >() ;
1734   unsigned int jresult = 0 ;
1735   void * jarg0 = 0 ;
1736
1737   if (!swig_callbackOnHoverEvent) {
1738     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1739   } else {
1740     jarg0 = (Dali::HoverEvent *) &event;
1741     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1742     c_result = jresult ? true : false;
1743   }
1744   return c_result;
1745 }
1746
1747 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1748   bool c_result = SwigValueInit< bool >() ;
1749   unsigned int jresult = 0 ;
1750   void * jarg0 = 0 ;
1751
1752   if (!swig_callbackOnKeyEvent) {
1753     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1754   } else {
1755     jarg0 = (Dali::KeyEvent *) &event;
1756     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1757     c_result = jresult ? true : false;
1758   }
1759   return c_result;
1760 }
1761
1762 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1763   bool c_result = SwigValueInit< bool >() ;
1764   unsigned int jresult = 0 ;
1765   void * jarg0 = 0 ;
1766
1767   if (!swig_callbackOnWheelEvent) {
1768     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1769   } else {
1770     jarg0 = (Dali::WheelEvent *) &event;
1771     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1772     c_result = jresult ? true : false;
1773   }
1774   return c_result;
1775 }
1776
1777 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1778   void * jsize = 0 ;
1779   void * jcontainer = 0 ;
1780
1781   if (!swig_callbackOnRelayout) {
1782     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1783     return;
1784   } else {
1785     jsize = (Dali::Vector2 *) &size;
1786     jcontainer = (Dali::RelayoutContainer *) &container;
1787     swig_callbackOnRelayout(jsize, jcontainer);
1788   }
1789 }
1790
1791 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1792   int jpolicy  ;
1793   int jdimension  ;
1794
1795   if (!swig_callbackOnSetResizePolicy) {
1796     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1797     return;
1798   } else {
1799     jpolicy = (int)policy;
1800     jdimension = (int)dimension;
1801     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1802   }
1803 }
1804
1805 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1806   Dali::Vector3 c_result ;
1807   void * jresult = 0 ;
1808
1809   if (!swig_callbackGetNaturalSize) {
1810     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1811   } else {
1812     jresult = (void *) swig_callbackGetNaturalSize();
1813     if (!jresult) {
1814       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1815       return c_result;
1816     }
1817     c_result = *(Dali::Vector3 *)jresult;
1818   }
1819   return c_result;
1820 }
1821
1822 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1823   float c_result = SwigValueInit< float >() ;
1824   float jresult = 0 ;
1825   void * jchild = 0 ;
1826   int jdimension  ;
1827
1828   if (!swig_callbackCalculateChildSize) {
1829     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1830   } else {
1831     jchild = (Dali::Actor *) &child;
1832     jdimension = (int)dimension;
1833     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1834     c_result = (float)jresult;
1835   }
1836   return c_result;
1837 }
1838
1839 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1840   float c_result = SwigValueInit< float >() ;
1841   float jresult = 0 ;
1842   float jwidth  ;
1843
1844   if (!swig_callbackGetHeightForWidth) {
1845     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1846   } else {
1847     jwidth = width;
1848     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1849     c_result = (float)jresult;
1850   }
1851   return c_result;
1852 }
1853
1854 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1855   float c_result = SwigValueInit< float >() ;
1856   float jresult = 0 ;
1857   float jheight  ;
1858
1859   if (!swig_callbackGetWidthForHeight) {
1860     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1861   } else {
1862     jheight = height;
1863     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1864     c_result = (float)jresult;
1865   }
1866   return c_result;
1867 }
1868
1869 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1870   bool c_result = SwigValueInit< bool >() ;
1871   unsigned int jresult = 0 ;
1872   int jdimension  ;
1873
1874   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1875     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1876   } else {
1877     jdimension = (int)dimension;
1878     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1879     c_result = jresult ? true : false;
1880   }
1881   return c_result;
1882 }
1883
1884 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1885   int jdimension  ;
1886
1887   if (!swig_callbackOnCalculateRelayoutSize) {
1888     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1889     return;
1890   } else {
1891     jdimension = (int)dimension;
1892     swig_callbackOnCalculateRelayoutSize(jdimension);
1893   }
1894 }
1895
1896 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1897   float jsize  ;
1898   int jdimension  ;
1899
1900   if (!swig_callbackOnLayoutNegotiated) {
1901     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1902     return;
1903   } else {
1904     jsize = size;
1905     jdimension = (int)dimension;
1906     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1907   }
1908 }
1909
1910 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1911   return Dali::CustomActorImpl::GetExtension();
1912 }
1913
1914 void SwigDirector_ViewImpl::OnInitialize() {
1915   if (!swig_callbackOnInitialize) {
1916     Dali::Toolkit::Internal::Control::OnInitialize();
1917     return;
1918   } else {
1919     swig_callbackOnInitialize();
1920   }
1921 }
1922
1923 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1924   void * jchild = 0 ;
1925
1926   if (!swig_callbackOnControlChildAdd) {
1927     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1928     return;
1929   } else {
1930     jchild = (Dali::Actor *) &child;
1931     swig_callbackOnControlChildAdd(jchild);
1932   }
1933 }
1934
1935 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1936   void * jchild = 0 ;
1937
1938   if (!swig_callbackOnControlChildRemove) {
1939     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1940     return;
1941   } else {
1942     jchild = (Dali::Actor *) &child;
1943     swig_callbackOnControlChildRemove(jchild);
1944   }
1945 }
1946
1947 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1948   void * jstyleManager  ;
1949   int jchange  ;
1950
1951   if (!swig_callbackOnStyleChange) {
1952     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1953     return;
1954   } else {
1955     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1956     jchange = (int)change;
1957     swig_callbackOnStyleChange(jstyleManager, jchange);
1958   }
1959 }
1960
1961 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1962   bool c_result = SwigValueInit< bool >() ;
1963   unsigned int jresult = 0 ;
1964
1965   if (!swig_callbackOnAccessibilityActivated) {
1966     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1967   } else {
1968     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1969     c_result = jresult ? true : false;
1970   }
1971   return c_result;
1972 }
1973
1974 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1975   bool c_result = SwigValueInit< bool >() ;
1976   unsigned int jresult = 0 ;
1977   void * jgesture  ;
1978
1979   if (!swig_callbackOnAccessibilityPan) {
1980     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1981   } else {
1982     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
1983     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
1984     c_result = jresult ? true : false;
1985   }
1986   return c_result;
1987 }
1988
1989 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
1990   bool c_result = SwigValueInit< bool >() ;
1991   unsigned int jresult = 0 ;
1992   void * jtouchEvent = 0 ;
1993
1994   if (!swig_callbackOnAccessibilityTouch) {
1995     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
1996   } else {
1997     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
1998     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
1999     c_result = jresult ? true : false;
2000   }
2001   return c_result;
2002 }
2003
2004 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2005   bool c_result = SwigValueInit< bool >() ;
2006   unsigned int jresult = 0 ;
2007   unsigned int jisIncrease  ;
2008
2009   if (!swig_callbackOnAccessibilityValueChange) {
2010     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2011   } else {
2012     jisIncrease = isIncrease;
2013     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2014     c_result = jresult ? true : false;
2015   }
2016   return c_result;
2017 }
2018
2019 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2020   bool c_result = SwigValueInit< bool >() ;
2021   unsigned int jresult = 0 ;
2022
2023   if (!swig_callbackOnAccessibilityZoom) {
2024     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2025   } else {
2026     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2027     c_result = jresult ? true : false;
2028   }
2029   return c_result;
2030 }
2031
2032 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2033   if (!swig_callbackOnKeyInputFocusGained) {
2034     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2035     return;
2036   } else {
2037     swig_callbackOnKeyInputFocusGained();
2038   }
2039 }
2040
2041 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2042   if (!swig_callbackOnKeyInputFocusLost) {
2043     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2044     return;
2045   } else {
2046     swig_callbackOnKeyInputFocusLost();
2047   }
2048 }
2049
2050 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2051   Dali::Actor c_result ;
2052   void * jresult = 0 ;
2053   void * jcurrentFocusedActor  ;
2054   int jdirection  ;
2055   unsigned int jloopEnabled  ;
2056
2057   if (!swig_callbackGetNextKeyboardFocusableActor) {
2058     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2059   } else {
2060     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2061     jdirection = (int)direction;
2062     jloopEnabled = loopEnabled;
2063     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2064     if (!jresult) {
2065       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2066       return c_result;
2067     }
2068     c_result = *(Dali::Actor *)jresult;
2069   }
2070   return c_result;
2071 }
2072
2073 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2074   void * jcommitedFocusableActor  ;
2075
2076   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2077     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2078     return;
2079   } else {
2080     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2081     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2082   }
2083 }
2084
2085 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2086   bool c_result = SwigValueInit< bool >() ;
2087   unsigned int jresult = 0 ;
2088
2089   if (!swig_callbackOnKeyboardEnter) {
2090     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2091   } else {
2092     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2093     c_result = jresult ? true : false;
2094   }
2095   return c_result;
2096 }
2097
2098 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2099   void * jpinch = 0 ;
2100
2101   if (!swig_callbackOnPinch) {
2102     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2103     return;
2104   } else {
2105     jpinch = (Dali::PinchGesture *) &pinch;
2106     swig_callbackOnPinch(jpinch);
2107   }
2108 }
2109
2110 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2111   void * jpan = 0 ;
2112
2113   if (!swig_callbackOnPan) {
2114     Dali::Toolkit::Internal::Control::OnPan(pan);
2115     return;
2116   } else {
2117     jpan = (Dali::PanGesture *) &pan;
2118     swig_callbackOnPan(jpan);
2119   }
2120 }
2121
2122 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2123   void * jtap = 0 ;
2124
2125   if (!swig_callbackOnTap) {
2126     Dali::Toolkit::Internal::Control::OnTap(tap);
2127     return;
2128   } else {
2129     jtap = (Dali::TapGesture *) &tap;
2130     swig_callbackOnTap(jtap);
2131   }
2132 }
2133
2134 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2135   void * jlongPress = 0 ;
2136
2137   if (!swig_callbackOnLongPress) {
2138     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2139     return;
2140   } else {
2141     jlongPress = (Dali::LongPressGesture *) &longPress;
2142     swig_callbackOnLongPress(jlongPress);
2143   }
2144 }
2145
2146 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2147   void * jslotObserver = 0 ;
2148   void * jcallback = 0 ;
2149
2150   if (!swig_callbackSignalConnected) {
2151     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2152     return;
2153   } else {
2154     jslotObserver = (void *) slotObserver;
2155     jcallback = (void *) callback;
2156     swig_callbackSignalConnected(jslotObserver, jcallback);
2157   }
2158 }
2159
2160 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2161   void * jslotObserver = 0 ;
2162   void * jcallback = 0 ;
2163
2164   if (!swig_callbackSignalDisconnected) {
2165     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2166     return;
2167   } else {
2168     jslotObserver = (void *) slotObserver;
2169     jcallback = (void *) callback;
2170     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2171   }
2172 }
2173
2174 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2175   return Dali::Toolkit::Internal::Control::GetControlExtension();
2176 }
2177
2178 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) {
2179   swig_callbackOnStageConnection = callbackOnStageConnection;
2180   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2181   swig_callbackOnChildAdd = callbackOnChildAdd;
2182   swig_callbackOnChildRemove = callbackOnChildRemove;
2183   swig_callbackOnPropertySet = callbackOnPropertySet;
2184   swig_callbackOnSizeSet = callbackOnSizeSet;
2185   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2186   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2187   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2188   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2189   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2190   swig_callbackOnRelayout = callbackOnRelayout;
2191   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2192   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2193   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2194   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2195   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2196   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2197   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2198   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2199   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2200   swig_callbackOnInitialize = callbackOnInitialize;
2201   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2202   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2203   swig_callbackOnStyleChange = callbackOnStyleChange;
2204   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2205   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2206   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2207   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2208   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2209   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2210   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2211   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2212   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2213   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2214   swig_callbackOnPinch = callbackOnPinch;
2215   swig_callbackOnPan = callbackOnPan;
2216   swig_callbackOnTap = callbackOnTap;
2217   swig_callbackOnLongPress = callbackOnLongPress;
2218   swig_callbackSignalConnected = callbackSignalConnected;
2219   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2220 }
2221
2222 void SwigDirector_ViewImpl::swig_init_callbacks() {
2223   swig_callbackOnStageConnection = 0;
2224   swig_callbackOnStageDisconnection = 0;
2225   swig_callbackOnChildAdd = 0;
2226   swig_callbackOnChildRemove = 0;
2227   swig_callbackOnPropertySet = 0;
2228   swig_callbackOnSizeSet = 0;
2229   swig_callbackOnSizeAnimation = 0;
2230   swig_callbackOnTouchEvent = 0;
2231   swig_callbackOnHoverEvent = 0;
2232   swig_callbackOnKeyEvent = 0;
2233   swig_callbackOnWheelEvent = 0;
2234   swig_callbackOnRelayout = 0;
2235   swig_callbackOnSetResizePolicy = 0;
2236   swig_callbackGetNaturalSize = 0;
2237   swig_callbackCalculateChildSize = 0;
2238   swig_callbackGetHeightForWidth = 0;
2239   swig_callbackGetWidthForHeight = 0;
2240   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2241   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2242   swig_callbackOnCalculateRelayoutSize = 0;
2243   swig_callbackOnLayoutNegotiated = 0;
2244   swig_callbackOnInitialize = 0;
2245   swig_callbackOnControlChildAdd = 0;
2246   swig_callbackOnControlChildRemove = 0;
2247   swig_callbackOnStyleChange = 0;
2248   swig_callbackOnAccessibilityActivated = 0;
2249   swig_callbackOnAccessibilityPan = 0;
2250   swig_callbackOnAccessibilityTouch = 0;
2251   swig_callbackOnAccessibilityValueChange = 0;
2252   swig_callbackOnAccessibilityZoom = 0;
2253   swig_callbackOnKeyInputFocusGained = 0;
2254   swig_callbackOnKeyInputFocusLost = 0;
2255   swig_callbackGetNextKeyboardFocusableActor = 0;
2256   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2257   swig_callbackOnKeyboardEnter = 0;
2258   swig_callbackOnPinch = 0;
2259   swig_callbackOnPan = 0;
2260   swig_callbackOnTap = 0;
2261   swig_callbackOnLongPress = 0;
2262   swig_callbackSignalConnected = 0;
2263   swig_callbackSignalDisconnected = 0;
2264 }
2265
2266 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2267   swig_init_callbacks();
2268 }
2269
2270 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2271
2272 }
2273
2274
2275 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2276   unsigned int c_result = SwigValueInit< unsigned int >() ;
2277   unsigned int jresult = 0 ;
2278
2279   if (!swig_callbackGetNumberOfItems) {
2280     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2281   } else {
2282     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2283     c_result = (unsigned int)jresult;
2284   }
2285   return c_result;
2286 }
2287
2288 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2289   Dali::Actor c_result ;
2290   void * jresult = 0 ;
2291   unsigned int jitemId  ;
2292
2293   if (!swig_callbackNewItem) {
2294     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2295   } else {
2296     jitemId = itemId;
2297     jresult = (void *) swig_callbackNewItem(jitemId);
2298     if (!jresult) {
2299       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2300       return c_result;
2301     }
2302     c_result = *(Dali::Actor *)jresult;
2303   }
2304   return c_result;
2305 }
2306
2307 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2308   unsigned int jitemId  ;
2309   void * jactor  ;
2310
2311   if (!swig_callbackItemReleased) {
2312     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2313     return;
2314   } else {
2315     jitemId = itemId;
2316     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2317     swig_callbackItemReleased(jitemId, jactor);
2318   }
2319 }
2320
2321 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2322   return Dali::Toolkit::ItemFactory::GetExtension();
2323 }
2324
2325 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2326   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2327   swig_callbackNewItem = callbackNewItem;
2328   swig_callbackItemReleased = callbackItemReleased;
2329 }
2330
2331 void SwigDirector_ItemFactory::swig_init_callbacks() {
2332   swig_callbackGetNumberOfItems = 0;
2333   swig_callbackNewItem = 0;
2334   swig_callbackItemReleased = 0;
2335 }
2336
2337 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2338   swig_init_callbacks();
2339 }
2340
2341 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2342
2343 }
2344
2345
2346 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2347   Dali::Actor c_result ;
2348   void * jresult = 0 ;
2349   void * jcurrent  ;
2350   void * jproposed  ;
2351   int jdirection  ;
2352
2353   if (!swig_callbackGetNextFocusableActor) {
2354     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2355   } else {
2356     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2357     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2358     jdirection = (int)direction;
2359     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2360     if (!jresult) {
2361       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2362       return c_result;
2363     }
2364     c_result = *(Dali::Actor *)jresult;
2365   }
2366   return c_result;
2367 }
2368
2369 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2370   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2371 }
2372
2373 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2374   swig_callbackGetNextFocusableActor = 0;
2375 }
2376
2377
2378 #ifdef __cplusplus
2379 extern "C" {
2380 #endif
2381
2382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2383   void * jresult ;
2384   floatp *result = 0 ;
2385
2386   {
2387     try {
2388       result = (floatp *)new_floatp();
2389     } catch (std::out_of_range& e) {
2390       {
2391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2392       };
2393     } catch (std::exception& e) {
2394       {
2395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2396       };
2397     } catch (...) {
2398       {
2399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2400       };
2401     }
2402   }
2403   jresult = (void *)result;
2404   return jresult;
2405 }
2406
2407
2408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2409   floatp *arg1 = (floatp *) 0 ;
2410
2411   arg1 = (floatp *)jarg1;
2412   {
2413     try {
2414       delete_floatp(arg1);
2415     } catch (std::out_of_range& e) {
2416       {
2417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2418       };
2419     } catch (std::exception& e) {
2420       {
2421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2422       };
2423     } catch (...) {
2424       {
2425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2426       };
2427     }
2428   }
2429 }
2430
2431
2432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2433   floatp *arg1 = (floatp *) 0 ;
2434   float arg2 ;
2435
2436   arg1 = (floatp *)jarg1;
2437   arg2 = (float)jarg2;
2438   {
2439     try {
2440       floatp_assign(arg1,arg2);
2441     } catch (std::out_of_range& e) {
2442       {
2443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2444       };
2445     } catch (std::exception& e) {
2446       {
2447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2448       };
2449     } catch (...) {
2450       {
2451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2452       };
2453     }
2454   }
2455 }
2456
2457
2458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2459   float jresult ;
2460   floatp *arg1 = (floatp *) 0 ;
2461   float result;
2462
2463   arg1 = (floatp *)jarg1;
2464   {
2465     try {
2466       result = (float)floatp_value(arg1);
2467     } catch (std::out_of_range& e) {
2468       {
2469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2470       };
2471     } catch (std::exception& e) {
2472       {
2473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2474       };
2475     } catch (...) {
2476       {
2477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2478       };
2479     }
2480   }
2481   jresult = result;
2482   return jresult;
2483 }
2484
2485
2486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2487   void * jresult ;
2488   floatp *arg1 = (floatp *) 0 ;
2489   float *result = 0 ;
2490
2491   arg1 = (floatp *)jarg1;
2492   {
2493     try {
2494       result = (float *)floatp_cast(arg1);
2495     } catch (std::out_of_range& e) {
2496       {
2497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2498       };
2499     } catch (std::exception& e) {
2500       {
2501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2502       };
2503     } catch (...) {
2504       {
2505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2506       };
2507     }
2508   }
2509   jresult = (void *)result;
2510   return jresult;
2511 }
2512
2513
2514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2515   void * jresult ;
2516   float *arg1 = (float *) 0 ;
2517   floatp *result = 0 ;
2518
2519   arg1 = (float *)jarg1;
2520   {
2521     try {
2522       result = (floatp *)floatp_frompointer(arg1);
2523     } catch (std::out_of_range& e) {
2524       {
2525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2526       };
2527     } catch (std::exception& e) {
2528       {
2529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2530       };
2531     } catch (...) {
2532       {
2533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2534       };
2535     }
2536   }
2537   jresult = (void *)result;
2538   return jresult;
2539 }
2540
2541
2542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2543   void * jresult ;
2544   intp *result = 0 ;
2545
2546   {
2547     try {
2548       result = (intp *)new_intp();
2549     } catch (std::out_of_range& e) {
2550       {
2551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2552       };
2553     } catch (std::exception& e) {
2554       {
2555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2556       };
2557     } catch (...) {
2558       {
2559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2560       };
2561     }
2562   }
2563   jresult = (void *)result;
2564   return jresult;
2565 }
2566
2567
2568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2569   intp *arg1 = (intp *) 0 ;
2570
2571   arg1 = (intp *)jarg1;
2572   {
2573     try {
2574       delete_intp(arg1);
2575     } catch (std::out_of_range& e) {
2576       {
2577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2578       };
2579     } catch (std::exception& e) {
2580       {
2581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2582       };
2583     } catch (...) {
2584       {
2585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2586       };
2587     }
2588   }
2589 }
2590
2591
2592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2593   intp *arg1 = (intp *) 0 ;
2594   int arg2 ;
2595
2596   arg1 = (intp *)jarg1;
2597   arg2 = (int)jarg2;
2598   {
2599     try {
2600       intp_assign(arg1,arg2);
2601     } catch (std::out_of_range& e) {
2602       {
2603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2604       };
2605     } catch (std::exception& e) {
2606       {
2607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2608       };
2609     } catch (...) {
2610       {
2611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2612       };
2613     }
2614   }
2615 }
2616
2617
2618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2619   int jresult ;
2620   intp *arg1 = (intp *) 0 ;
2621   int result;
2622
2623   arg1 = (intp *)jarg1;
2624   {
2625     try {
2626       result = (int)intp_value(arg1);
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2634       };
2635     } catch (...) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2638       };
2639     }
2640   }
2641   jresult = result;
2642   return jresult;
2643 }
2644
2645
2646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2647   void * jresult ;
2648   intp *arg1 = (intp *) 0 ;
2649   int *result = 0 ;
2650
2651   arg1 = (intp *)jarg1;
2652   {
2653     try {
2654       result = (int *)intp_cast(arg1);
2655     } catch (std::out_of_range& e) {
2656       {
2657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2658       };
2659     } catch (std::exception& e) {
2660       {
2661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2662       };
2663     } catch (...) {
2664       {
2665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2666       };
2667     }
2668   }
2669   jresult = (void *)result;
2670   return jresult;
2671 }
2672
2673
2674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2675   void * jresult ;
2676   int *arg1 = (int *) 0 ;
2677   intp *result = 0 ;
2678
2679   arg1 = (int *)jarg1;
2680   {
2681     try {
2682       result = (intp *)intp_frompointer(arg1);
2683     } catch (std::out_of_range& e) {
2684       {
2685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2686       };
2687     } catch (std::exception& e) {
2688       {
2689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2690       };
2691     } catch (...) {
2692       {
2693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2694       };
2695     }
2696   }
2697   jresult = (void *)result;
2698   return jresult;
2699 }
2700
2701
2702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2703   void * jresult ;
2704   doublep *result = 0 ;
2705
2706   {
2707     try {
2708       result = (doublep *)new_doublep();
2709     } catch (std::out_of_range& e) {
2710       {
2711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2712       };
2713     } catch (std::exception& e) {
2714       {
2715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2716       };
2717     } catch (...) {
2718       {
2719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2720       };
2721     }
2722   }
2723   jresult = (void *)result;
2724   return jresult;
2725 }
2726
2727
2728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2729   doublep *arg1 = (doublep *) 0 ;
2730
2731   arg1 = (doublep *)jarg1;
2732   {
2733     try {
2734       delete_doublep(arg1);
2735     } catch (std::out_of_range& e) {
2736       {
2737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2738       };
2739     } catch (std::exception& e) {
2740       {
2741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2742       };
2743     } catch (...) {
2744       {
2745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2746       };
2747     }
2748   }
2749 }
2750
2751
2752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2753   doublep *arg1 = (doublep *) 0 ;
2754   double arg2 ;
2755
2756   arg1 = (doublep *)jarg1;
2757   arg2 = (double)jarg2;
2758   {
2759     try {
2760       doublep_assign(arg1,arg2);
2761     } catch (std::out_of_range& e) {
2762       {
2763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2764       };
2765     } catch (std::exception& e) {
2766       {
2767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2768       };
2769     } catch (...) {
2770       {
2771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2772       };
2773     }
2774   }
2775 }
2776
2777
2778 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2779   double jresult ;
2780   doublep *arg1 = (doublep *) 0 ;
2781   double result;
2782
2783   arg1 = (doublep *)jarg1;
2784   {
2785     try {
2786       result = (double)doublep_value(arg1);
2787     } catch (std::out_of_range& e) {
2788       {
2789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (std::exception& e) {
2792       {
2793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2794       };
2795     } catch (...) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2798       };
2799     }
2800   }
2801   jresult = result;
2802   return jresult;
2803 }
2804
2805
2806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2807   void * jresult ;
2808   doublep *arg1 = (doublep *) 0 ;
2809   double *result = 0 ;
2810
2811   arg1 = (doublep *)jarg1;
2812   {
2813     try {
2814       result = (double *)doublep_cast(arg1);
2815     } catch (std::out_of_range& e) {
2816       {
2817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2818       };
2819     } catch (std::exception& e) {
2820       {
2821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2822       };
2823     } catch (...) {
2824       {
2825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2826       };
2827     }
2828   }
2829   jresult = (void *)result;
2830   return jresult;
2831 }
2832
2833
2834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2835   void * jresult ;
2836   double *arg1 = (double *) 0 ;
2837   doublep *result = 0 ;
2838
2839   arg1 = (double *)jarg1;
2840   {
2841     try {
2842       result = (doublep *)doublep_frompointer(arg1);
2843     } catch (std::out_of_range& e) {
2844       {
2845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2846       };
2847     } catch (std::exception& e) {
2848       {
2849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2850       };
2851     } catch (...) {
2852       {
2853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2854       };
2855     }
2856   }
2857   jresult = (void *)result;
2858   return jresult;
2859 }
2860
2861
2862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2863   void * jresult ;
2864   uintp *result = 0 ;
2865
2866   {
2867     try {
2868       result = (uintp *)new_uintp();
2869     } catch (std::out_of_range& e) {
2870       {
2871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2872       };
2873     } catch (std::exception& e) {
2874       {
2875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2876       };
2877     } catch (...) {
2878       {
2879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2880       };
2881     }
2882   }
2883   jresult = (void *)result;
2884   return jresult;
2885 }
2886
2887
2888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2889   uintp *arg1 = (uintp *) 0 ;
2890
2891   arg1 = (uintp *)jarg1;
2892   {
2893     try {
2894       delete_uintp(arg1);
2895     } catch (std::out_of_range& e) {
2896       {
2897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2898       };
2899     } catch (std::exception& e) {
2900       {
2901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2902       };
2903     } catch (...) {
2904       {
2905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2906       };
2907     }
2908   }
2909 }
2910
2911
2912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2913   uintp *arg1 = (uintp *) 0 ;
2914   unsigned int arg2 ;
2915
2916   arg1 = (uintp *)jarg1;
2917   arg2 = (unsigned int)jarg2;
2918   {
2919     try {
2920       uintp_assign(arg1,arg2);
2921     } catch (std::out_of_range& e) {
2922       {
2923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2924       };
2925     } catch (std::exception& e) {
2926       {
2927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2928       };
2929     } catch (...) {
2930       {
2931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2932       };
2933     }
2934   }
2935 }
2936
2937
2938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2939   unsigned int jresult ;
2940   uintp *arg1 = (uintp *) 0 ;
2941   unsigned int result;
2942
2943   arg1 = (uintp *)jarg1;
2944   {
2945     try {
2946       result = (unsigned int)uintp_value(arg1);
2947     } catch (std::out_of_range& e) {
2948       {
2949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2950       };
2951     } catch (std::exception& e) {
2952       {
2953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2954       };
2955     } catch (...) {
2956       {
2957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2958       };
2959     }
2960   }
2961   jresult = result;
2962   return jresult;
2963 }
2964
2965
2966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2967   void * jresult ;
2968   uintp *arg1 = (uintp *) 0 ;
2969   unsigned int *result = 0 ;
2970
2971   arg1 = (uintp *)jarg1;
2972   {
2973     try {
2974       result = (unsigned int *)uintp_cast(arg1);
2975     } catch (std::out_of_range& e) {
2976       {
2977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2978       };
2979     } catch (std::exception& e) {
2980       {
2981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2982       };
2983     } catch (...) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2986       };
2987     }
2988   }
2989   jresult = (void *)result;
2990   return jresult;
2991 }
2992
2993
2994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2995   void * jresult ;
2996   unsigned int *arg1 = (unsigned int *) 0 ;
2997   uintp *result = 0 ;
2998
2999   arg1 = (unsigned int *)jarg1;
3000   {
3001     try {
3002       result = (uintp *)uintp_frompointer(arg1);
3003     } catch (std::out_of_range& e) {
3004       {
3005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3006       };
3007     } catch (std::exception& e) {
3008       {
3009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3010       };
3011     } catch (...) {
3012       {
3013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3014       };
3015     }
3016   }
3017   jresult = (void *)result;
3018   return jresult;
3019 }
3020
3021
3022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3023   void * jresult ;
3024   ushortp *result = 0 ;
3025
3026   {
3027     try {
3028       result = (ushortp *)new_ushortp();
3029     } catch (std::out_of_range& e) {
3030       {
3031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3032       };
3033     } catch (std::exception& e) {
3034       {
3035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3036       };
3037     } catch (...) {
3038       {
3039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3040       };
3041     }
3042   }
3043   jresult = (void *)result;
3044   return jresult;
3045 }
3046
3047
3048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3049   ushortp *arg1 = (ushortp *) 0 ;
3050
3051   arg1 = (ushortp *)jarg1;
3052   {
3053     try {
3054       delete_ushortp(arg1);
3055     } catch (std::out_of_range& e) {
3056       {
3057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3058       };
3059     } catch (std::exception& e) {
3060       {
3061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3062       };
3063     } catch (...) {
3064       {
3065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3066       };
3067     }
3068   }
3069 }
3070
3071
3072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3073   ushortp *arg1 = (ushortp *) 0 ;
3074   unsigned short arg2 ;
3075
3076   arg1 = (ushortp *)jarg1;
3077   arg2 = (unsigned short)jarg2;
3078   {
3079     try {
3080       ushortp_assign(arg1,arg2);
3081     } catch (std::out_of_range& e) {
3082       {
3083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3084       };
3085     } catch (std::exception& e) {
3086       {
3087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3088       };
3089     } catch (...) {
3090       {
3091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3092       };
3093     }
3094   }
3095 }
3096
3097
3098 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3099   unsigned short jresult ;
3100   ushortp *arg1 = (ushortp *) 0 ;
3101   unsigned short result;
3102
3103   arg1 = (ushortp *)jarg1;
3104   {
3105     try {
3106       result = (unsigned short)ushortp_value(arg1);
3107     } catch (std::out_of_range& e) {
3108       {
3109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (std::exception& e) {
3112       {
3113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121   jresult = result;
3122   return jresult;
3123 }
3124
3125
3126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3127   void * jresult ;
3128   ushortp *arg1 = (ushortp *) 0 ;
3129   unsigned short *result = 0 ;
3130
3131   arg1 = (ushortp *)jarg1;
3132   {
3133     try {
3134       result = (unsigned short *)ushortp_cast(arg1);
3135     } catch (std::out_of_range& e) {
3136       {
3137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3138       };
3139     } catch (std::exception& e) {
3140       {
3141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3142       };
3143     } catch (...) {
3144       {
3145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3146       };
3147     }
3148   }
3149   jresult = (void *)result;
3150   return jresult;
3151 }
3152
3153
3154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3155   void * jresult ;
3156   unsigned short *arg1 = (unsigned short *) 0 ;
3157   ushortp *result = 0 ;
3158
3159   arg1 = (unsigned short *)jarg1;
3160   {
3161     try {
3162       result = (ushortp *)ushortp_frompointer(arg1);
3163     } catch (std::out_of_range& e) {
3164       {
3165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3166       };
3167     } catch (std::exception& e) {
3168       {
3169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3170       };
3171     } catch (...) {
3172       {
3173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3174       };
3175     }
3176   }
3177   jresult = (void *)result;
3178   return jresult;
3179 }
3180
3181
3182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3183   unsigned int jresult ;
3184   int arg1 ;
3185   unsigned int result;
3186
3187   arg1 = (int)jarg1;
3188   {
3189     try {
3190       result = (unsigned int)int_to_uint(arg1);
3191     } catch (std::out_of_range& e) {
3192       {
3193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3194       };
3195     } catch (std::exception& e) {
3196       {
3197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3198       };
3199     } catch (...) {
3200       {
3201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3202       };
3203     }
3204   }
3205   jresult = result;
3206   return jresult;
3207 }
3208
3209
3210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3211   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3212
3213   arg1 = (Dali::RefObject *)jarg1;
3214   {
3215     try {
3216       (arg1)->Reference();
3217     } catch (std::out_of_range& e) {
3218       {
3219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3220       };
3221     } catch (std::exception& e) {
3222       {
3223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3224       };
3225     } catch (...) {
3226       {
3227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3228       };
3229     }
3230   }
3231 }
3232
3233
3234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3235   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3236
3237   arg1 = (Dali::RefObject *)jarg1;
3238   {
3239     try {
3240       (arg1)->Unreference();
3241     } catch (std::out_of_range& e) {
3242       {
3243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3244       };
3245     } catch (std::exception& e) {
3246       {
3247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3248       };
3249     } catch (...) {
3250       {
3251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3252       };
3253     }
3254   }
3255 }
3256
3257
3258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3259   int jresult ;
3260   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3261   int result;
3262
3263   arg1 = (Dali::RefObject *)jarg1;
3264   {
3265     try {
3266       result = (int)(arg1)->ReferenceCount();
3267     } catch (std::out_of_range& e) {
3268       {
3269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3270       };
3271     } catch (std::exception& e) {
3272       {
3273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3274       };
3275     } catch (...) {
3276       {
3277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3278       };
3279     }
3280   }
3281   jresult = result;
3282   return jresult;
3283 }
3284
3285
3286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3287   void * jresult ;
3288   Dali::Any *result = 0 ;
3289
3290   {
3291     try {
3292       result = (Dali::Any *)new Dali::Any();
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (...) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3304       };
3305     }
3306   }
3307   jresult = (void *)result;
3308   return jresult;
3309 }
3310
3311
3312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3313   Dali::Any *arg1 = (Dali::Any *) 0 ;
3314
3315   arg1 = (Dali::Any *)jarg1;
3316   {
3317     try {
3318       delete arg1;
3319     } catch (std::out_of_range& e) {
3320       {
3321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3322       };
3323     } catch (std::exception& e) {
3324       {
3325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3326       };
3327     } catch (...) {
3328       {
3329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3330       };
3331     }
3332   }
3333 }
3334
3335
3336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3337   char *arg1 = (char *) 0 ;
3338
3339   arg1 = (char *)jarg1;
3340   {
3341     try {
3342       Dali::Any::AssertAlways((char const *)arg1);
3343     } catch (std::out_of_range& e) {
3344       {
3345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3346       };
3347     } catch (std::exception& e) {
3348       {
3349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3350       };
3351     } catch (...) {
3352       {
3353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3354       };
3355     }
3356   }
3357 }
3358
3359
3360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3361   void * jresult ;
3362   Dali::Any *arg1 = 0 ;
3363   Dali::Any *result = 0 ;
3364
3365   arg1 = (Dali::Any *)jarg1;
3366   if (!arg1) {
3367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3368     return 0;
3369   }
3370   {
3371     try {
3372       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3373     } catch (std::out_of_range& e) {
3374       {
3375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3376       };
3377     } catch (std::exception& e) {
3378       {
3379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3380       };
3381     } catch (...) {
3382       {
3383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3384       };
3385     }
3386   }
3387   jresult = (void *)result;
3388   return jresult;
3389 }
3390
3391
3392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3393   void * jresult ;
3394   Dali::Any *arg1 = (Dali::Any *) 0 ;
3395   Dali::Any *arg2 = 0 ;
3396   Dali::Any *result = 0 ;
3397
3398   arg1 = (Dali::Any *)jarg1;
3399   arg2 = (Dali::Any *)jarg2;
3400   if (!arg2) {
3401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3402     return 0;
3403   }
3404   {
3405     try {
3406       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3407     } catch (std::out_of_range& e) {
3408       {
3409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3410       };
3411     } catch (std::exception& e) {
3412       {
3413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3414       };
3415     } catch (...) {
3416       {
3417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3418       };
3419     }
3420   }
3421   jresult = (void *)result;
3422   return jresult;
3423 }
3424
3425
3426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3427   void * jresult ;
3428   Dali::Any *arg1 = (Dali::Any *) 0 ;
3429   std::type_info *result = 0 ;
3430
3431   arg1 = (Dali::Any *)jarg1;
3432   {
3433     try {
3434       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3435     } catch (std::out_of_range& e) {
3436       {
3437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3438       };
3439     } catch (std::exception& e) {
3440       {
3441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3442       };
3443     } catch (...) {
3444       {
3445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3446       };
3447     }
3448   }
3449   jresult = (void *)result;
3450   return jresult;
3451 }
3452
3453
3454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3455   unsigned int jresult ;
3456   Dali::Any *arg1 = (Dali::Any *) 0 ;
3457   bool result;
3458
3459   arg1 = (Dali::Any *)jarg1;
3460   {
3461     try {
3462       result = (bool)((Dali::Any const *)arg1)->Empty();
3463     } catch (std::out_of_range& e) {
3464       {
3465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3466       };
3467     } catch (std::exception& e) {
3468       {
3469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3470       };
3471     } catch (...) {
3472       {
3473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3474       };
3475     }
3476   }
3477   jresult = result;
3478   return jresult;
3479 }
3480
3481
3482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3483   void * jresult ;
3484   std::type_info *arg1 = 0 ;
3485   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3486   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3487   Dali::Any::AnyContainerBase *result = 0 ;
3488
3489   arg1 = (std::type_info *)jarg1;
3490   if (!arg1) {
3491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3492     return 0;
3493   }
3494   arg2 = (Dali::Any::CloneFunc)jarg2;
3495   arg3 = (Dali::Any::DeleteFunc)jarg3;
3496   {
3497     try {
3498       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3499     } catch (std::out_of_range& e) {
3500       {
3501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3502       };
3503     } catch (std::exception& e) {
3504       {
3505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3506       };
3507     } catch (...) {
3508       {
3509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3510       };
3511     }
3512   }
3513   jresult = (void *)result;
3514   return jresult;
3515 }
3516
3517
3518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3519   void * jresult ;
3520   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3521   std::type_info *result = 0 ;
3522
3523   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3524   {
3525     try {
3526       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3527     } catch (std::out_of_range& e) {
3528       {
3529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3530       };
3531     } catch (std::exception& e) {
3532       {
3533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3534       };
3535     } catch (...) {
3536       {
3537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3538       };
3539     }
3540   }
3541   jresult = (void *)result;
3542   return jresult;
3543 }
3544
3545
3546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3547   void * jresult ;
3548   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3549   ::std::type_info *result = 0 ;
3550
3551   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3552   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3553   jresult = (void *)result;
3554   return jresult;
3555 }
3556
3557
3558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3559   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3560   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3561
3562   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3563   arg2 = (Dali::Any::CloneFunc)jarg2;
3564   if (arg1) (arg1)->mCloneFunc = arg2;
3565 }
3566
3567
3568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3569   void * jresult ;
3570   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3571   Dali::Any::CloneFunc result;
3572
3573   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3574   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3575   jresult = (void *)result;
3576   return jresult;
3577 }
3578
3579
3580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3581   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3582   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3583
3584   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3585   arg2 = (Dali::Any::DeleteFunc)jarg2;
3586   if (arg1) (arg1)->mDeleteFunc = arg2;
3587 }
3588
3589
3590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3591   void * jresult ;
3592   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3593   Dali::Any::DeleteFunc result;
3594
3595   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3596   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3597   jresult = (void *)result;
3598   return jresult;
3599 }
3600
3601
3602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3603   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3604
3605   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3606   {
3607     try {
3608       delete arg1;
3609     } catch (std::out_of_range& e) {
3610       {
3611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3612       };
3613     } catch (std::exception& e) {
3614       {
3615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3616       };
3617     } catch (...) {
3618       {
3619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3620       };
3621     }
3622   }
3623 }
3624
3625
3626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3627   Dali::Any *arg1 = (Dali::Any *) 0 ;
3628   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3629
3630   arg1 = (Dali::Any *)jarg1;
3631   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3632   if (arg1) (arg1)->mContainer = arg2;
3633 }
3634
3635
3636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3637   void * jresult ;
3638   Dali::Any *arg1 = (Dali::Any *) 0 ;
3639   Dali::Any::AnyContainerBase *result = 0 ;
3640
3641   arg1 = (Dali::Any *)jarg1;
3642   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3643   jresult = (void *)result;
3644   return jresult;
3645 }
3646
3647
3648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3649   char *arg1 = (char *) 0 ;
3650   char *arg2 = (char *) 0 ;
3651
3652   arg1 = (char *)jarg1;
3653   arg2 = (char *)jarg2;
3654   {
3655     try {
3656       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3657     } catch (std::out_of_range& e) {
3658       {
3659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3660       };
3661     } catch (std::exception& e) {
3662       {
3663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3664       };
3665     } catch (...) {
3666       {
3667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3668       };
3669     }
3670   }
3671 }
3672
3673
3674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3675   void * jresult ;
3676   char *arg1 = (char *) 0 ;
3677   char *arg2 = (char *) 0 ;
3678   Dali::DaliException *result = 0 ;
3679
3680   arg1 = (char *)jarg1;
3681   arg2 = (char *)jarg2;
3682   {
3683     try {
3684       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3685     } catch (std::out_of_range& e) {
3686       {
3687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3688       };
3689     } catch (std::exception& e) {
3690       {
3691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3692       };
3693     } catch (...) {
3694       {
3695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3696       };
3697     }
3698   }
3699   jresult = (void *)result;
3700   return jresult;
3701 }
3702
3703
3704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3705   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3706   char *arg2 = (char *) 0 ;
3707
3708   arg1 = (Dali::DaliException *)jarg1;
3709   arg2 = (char *)jarg2;
3710   {
3711     if (arg2) {
3712       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3713       strcpy((char *)arg1->location, (const char *)arg2);
3714     } else {
3715       arg1->location = 0;
3716     }
3717   }
3718 }
3719
3720
3721 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3722   char * jresult ;
3723   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3724   char *result = 0 ;
3725
3726   arg1 = (Dali::DaliException *)jarg1;
3727   result = (char *) ((arg1)->location);
3728   jresult = SWIG_csharp_string_callback((const char *)result);
3729   return jresult;
3730 }
3731
3732
3733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3734   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3735   char *arg2 = (char *) 0 ;
3736
3737   arg1 = (Dali::DaliException *)jarg1;
3738   arg2 = (char *)jarg2;
3739   {
3740     if (arg2) {
3741       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3742       strcpy((char *)arg1->condition, (const char *)arg2);
3743     } else {
3744       arg1->condition = 0;
3745     }
3746   }
3747 }
3748
3749
3750 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3751   char * jresult ;
3752   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3753   char *result = 0 ;
3754
3755   arg1 = (Dali::DaliException *)jarg1;
3756   result = (char *) ((arg1)->condition);
3757   jresult = SWIG_csharp_string_callback((const char *)result);
3758   return jresult;
3759 }
3760
3761
3762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3763   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3764
3765   arg1 = (Dali::DaliException *)jarg1;
3766   {
3767     try {
3768       delete arg1;
3769     } catch (std::out_of_range& e) {
3770       {
3771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3772       };
3773     } catch (std::exception& e) {
3774       {
3775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3776       };
3777     } catch (...) {
3778       {
3779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3780       };
3781     }
3782   }
3783 }
3784
3785
3786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3787   void * jresult ;
3788   Dali::Vector2 *result = 0 ;
3789
3790   {
3791     try {
3792       result = (Dali::Vector2 *)new Dali::Vector2();
3793     } catch (std::out_of_range& e) {
3794       {
3795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3796       };
3797     } catch (std::exception& e) {
3798       {
3799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3800       };
3801     } catch (...) {
3802       {
3803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3804       };
3805     }
3806   }
3807   jresult = (void *)result;
3808   return jresult;
3809 }
3810
3811
3812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3813   void * jresult ;
3814   float arg1 ;
3815   float arg2 ;
3816   Dali::Vector2 *result = 0 ;
3817
3818   arg1 = (float)jarg1;
3819   arg2 = (float)jarg2;
3820   {
3821     try {
3822       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3823     } catch (std::out_of_range& e) {
3824       {
3825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3826       };
3827     } catch (std::exception& e) {
3828       {
3829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3830       };
3831     } catch (...) {
3832       {
3833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3834       };
3835     }
3836   }
3837   jresult = (void *)result;
3838   return jresult;
3839 }
3840
3841
3842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3843   void * jresult ;
3844   float *arg1 = (float *) 0 ;
3845   Dali::Vector2 *result = 0 ;
3846
3847   arg1 = jarg1;
3848   {
3849     try {
3850       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3851     } catch (std::out_of_range& e) {
3852       {
3853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3854       };
3855     } catch (std::exception& e) {
3856       {
3857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3858       };
3859     } catch (...) {
3860       {
3861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3862       };
3863     }
3864   }
3865   jresult = (void *)result;
3866
3867
3868   return jresult;
3869 }
3870
3871
3872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3873   void * jresult ;
3874   Dali::Vector3 *arg1 = 0 ;
3875   Dali::Vector2 *result = 0 ;
3876
3877   arg1 = (Dali::Vector3 *)jarg1;
3878   if (!arg1) {
3879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3880     return 0;
3881   }
3882   {
3883     try {
3884       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3885     } catch (std::out_of_range& e) {
3886       {
3887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3888       };
3889     } catch (std::exception& e) {
3890       {
3891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3892       };
3893     } catch (...) {
3894       {
3895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3896       };
3897     }
3898   }
3899   jresult = (void *)result;
3900   return jresult;
3901 }
3902
3903
3904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3905   void * jresult ;
3906   Dali::Vector4 *arg1 = 0 ;
3907   Dali::Vector2 *result = 0 ;
3908
3909   arg1 = (Dali::Vector4 *)jarg1;
3910   if (!arg1) {
3911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3912     return 0;
3913   }
3914   {
3915     try {
3916       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3917     } catch (std::out_of_range& e) {
3918       {
3919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3920       };
3921     } catch (std::exception& e) {
3922       {
3923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3924       };
3925     } catch (...) {
3926       {
3927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3928       };
3929     }
3930   }
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3937   void * jresult ;
3938   Dali::Vector2 *result = 0 ;
3939
3940   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3941   jresult = (void *)result;
3942   return jresult;
3943 }
3944
3945
3946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3947   void * jresult ;
3948   Dali::Vector2 *result = 0 ;
3949
3950   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3951   jresult = (void *)result;
3952   return jresult;
3953 }
3954
3955
3956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3957   void * jresult ;
3958   Dali::Vector2 *result = 0 ;
3959
3960   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3961   jresult = (void *)result;
3962   return jresult;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3967   void * jresult ;
3968   Dali::Vector2 *result = 0 ;
3969
3970   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3971   jresult = (void *)result;
3972   return jresult;
3973 }
3974
3975
3976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3977   void * jresult ;
3978   Dali::Vector2 *result = 0 ;
3979
3980   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3981   jresult = (void *)result;
3982   return jresult;
3983 }
3984
3985
3986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3987   void * jresult ;
3988   Dali::Vector2 *result = 0 ;
3989
3990   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3991   jresult = (void *)result;
3992   return jresult;
3993 }
3994
3995
3996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3997   void * jresult ;
3998   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3999   float *arg2 = (float *) 0 ;
4000   Dali::Vector2 *result = 0 ;
4001
4002   arg1 = (Dali::Vector2 *)jarg1;
4003   arg2 = jarg2;
4004   {
4005     try {
4006       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4007     } catch (std::out_of_range& e) {
4008       {
4009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4010       };
4011     } catch (std::exception& e) {
4012       {
4013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4014       };
4015     } catch (...) {
4016       {
4017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4018       };
4019     }
4020   }
4021   jresult = (void *)result;
4022
4023
4024   return jresult;
4025 }
4026
4027
4028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4029   void * jresult ;
4030   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4031   Dali::Vector3 *arg2 = 0 ;
4032   Dali::Vector2 *result = 0 ;
4033
4034   arg1 = (Dali::Vector2 *)jarg1;
4035   arg2 = (Dali::Vector3 *)jarg2;
4036   if (!arg2) {
4037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4038     return 0;
4039   }
4040   {
4041     try {
4042       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4043     } catch (std::out_of_range& e) {
4044       {
4045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4046       };
4047     } catch (std::exception& e) {
4048       {
4049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4050       };
4051     } catch (...) {
4052       {
4053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4054       };
4055     }
4056   }
4057   jresult = (void *)result;
4058   return jresult;
4059 }
4060
4061
4062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4063   void * jresult ;
4064   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4065   Dali::Vector4 *arg2 = 0 ;
4066   Dali::Vector2 *result = 0 ;
4067
4068   arg1 = (Dali::Vector2 *)jarg1;
4069   arg2 = (Dali::Vector4 *)jarg2;
4070   if (!arg2) {
4071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4072     return 0;
4073   }
4074   {
4075     try {
4076       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4077     } catch (std::out_of_range& e) {
4078       {
4079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4080       };
4081     } catch (std::exception& e) {
4082       {
4083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4084       };
4085     } catch (...) {
4086       {
4087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4088       };
4089     }
4090   }
4091   jresult = (void *)result;
4092   return jresult;
4093 }
4094
4095
4096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4097   void * jresult ;
4098   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4099   Dali::Vector2 *arg2 = 0 ;
4100   Dali::Vector2 result;
4101
4102   arg1 = (Dali::Vector2 *)jarg1;
4103   arg2 = (Dali::Vector2 *)jarg2;
4104   if (!arg2) {
4105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4106     return 0;
4107   }
4108   {
4109     try {
4110       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4111     } catch (std::out_of_range& e) {
4112       {
4113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4114       };
4115     } catch (std::exception& e) {
4116       {
4117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4118       };
4119     } catch (...) {
4120       {
4121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4122       };
4123     }
4124   }
4125   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4126   return jresult;
4127 }
4128
4129
4130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4131   void * jresult ;
4132   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4133   Dali::Vector2 *arg2 = 0 ;
4134   Dali::Vector2 *result = 0 ;
4135
4136   arg1 = (Dali::Vector2 *)jarg1;
4137   arg2 = (Dali::Vector2 *)jarg2;
4138   if (!arg2) {
4139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4140     return 0;
4141   }
4142   {
4143     try {
4144       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4145     } catch (std::out_of_range& e) {
4146       {
4147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4148       };
4149     } catch (std::exception& e) {
4150       {
4151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4152       };
4153     } catch (...) {
4154       {
4155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4156       };
4157     }
4158   }
4159   jresult = (void *)result;
4160   return jresult;
4161 }
4162
4163
4164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4165   void * jresult ;
4166   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4167   Dali::Vector2 *arg2 = 0 ;
4168   Dali::Vector2 result;
4169
4170   arg1 = (Dali::Vector2 *)jarg1;
4171   arg2 = (Dali::Vector2 *)jarg2;
4172   if (!arg2) {
4173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4174     return 0;
4175   }
4176   {
4177     try {
4178       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4179     } catch (std::out_of_range& e) {
4180       {
4181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4182       };
4183     } catch (std::exception& e) {
4184       {
4185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4186       };
4187     } catch (...) {
4188       {
4189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4190       };
4191     }
4192   }
4193   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4194   return jresult;
4195 }
4196
4197
4198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4199   void * jresult ;
4200   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4201   Dali::Vector2 *arg2 = 0 ;
4202   Dali::Vector2 *result = 0 ;
4203
4204   arg1 = (Dali::Vector2 *)jarg1;
4205   arg2 = (Dali::Vector2 *)jarg2;
4206   if (!arg2) {
4207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4208     return 0;
4209   }
4210   {
4211     try {
4212       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4213     } catch (std::out_of_range& e) {
4214       {
4215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4216       };
4217     } catch (std::exception& e) {
4218       {
4219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4220       };
4221     } catch (...) {
4222       {
4223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4224       };
4225     }
4226   }
4227   jresult = (void *)result;
4228   return jresult;
4229 }
4230
4231
4232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4233   void * jresult ;
4234   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4235   Dali::Vector2 *arg2 = 0 ;
4236   Dali::Vector2 result;
4237
4238   arg1 = (Dali::Vector2 *)jarg1;
4239   arg2 = (Dali::Vector2 *)jarg2;
4240   if (!arg2) {
4241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4242     return 0;
4243   }
4244   {
4245     try {
4246       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4247     } catch (std::out_of_range& e) {
4248       {
4249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4250       };
4251     } catch (std::exception& e) {
4252       {
4253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4254       };
4255     } catch (...) {
4256       {
4257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4258       };
4259     }
4260   }
4261   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4262   return jresult;
4263 }
4264
4265
4266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4267   void * jresult ;
4268   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4269   float arg2 ;
4270   Dali::Vector2 result;
4271
4272   arg1 = (Dali::Vector2 *)jarg1;
4273   arg2 = (float)jarg2;
4274   {
4275     try {
4276       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4277     } catch (std::out_of_range& e) {
4278       {
4279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4280       };
4281     } catch (std::exception& e) {
4282       {
4283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4284       };
4285     } catch (...) {
4286       {
4287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4288       };
4289     }
4290   }
4291   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4292   return jresult;
4293 }
4294
4295
4296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4297   void * jresult ;
4298   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4299   Dali::Vector2 *arg2 = 0 ;
4300   Dali::Vector2 *result = 0 ;
4301
4302   arg1 = (Dali::Vector2 *)jarg1;
4303   arg2 = (Dali::Vector2 *)jarg2;
4304   if (!arg2) {
4305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4306     return 0;
4307   }
4308   {
4309     try {
4310       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4311     } catch (std::out_of_range& e) {
4312       {
4313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4314       };
4315     } catch (std::exception& e) {
4316       {
4317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4318       };
4319     } catch (...) {
4320       {
4321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4322       };
4323     }
4324   }
4325   jresult = (void *)result;
4326   return jresult;
4327 }
4328
4329
4330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4331   void * jresult ;
4332   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4333   float arg2 ;
4334   Dali::Vector2 *result = 0 ;
4335
4336   arg1 = (Dali::Vector2 *)jarg1;
4337   arg2 = (float)jarg2;
4338   {
4339     try {
4340       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4341     } catch (std::out_of_range& e) {
4342       {
4343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4344       };
4345     } catch (std::exception& e) {
4346       {
4347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4348       };
4349     } catch (...) {
4350       {
4351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4352       };
4353     }
4354   }
4355   jresult = (void *)result;
4356   return jresult;
4357 }
4358
4359
4360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4361   void * jresult ;
4362   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4363   Dali::Vector2 *arg2 = 0 ;
4364   Dali::Vector2 result;
4365
4366   arg1 = (Dali::Vector2 *)jarg1;
4367   arg2 = (Dali::Vector2 *)jarg2;
4368   if (!arg2) {
4369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4370     return 0;
4371   }
4372   {
4373     try {
4374       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4375     } catch (std::out_of_range& e) {
4376       {
4377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4378       };
4379     } catch (std::exception& e) {
4380       {
4381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4382       };
4383     } catch (...) {
4384       {
4385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4386       };
4387     }
4388   }
4389   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4390   return jresult;
4391 }
4392
4393
4394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4395   void * jresult ;
4396   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4397   float arg2 ;
4398   Dali::Vector2 result;
4399
4400   arg1 = (Dali::Vector2 *)jarg1;
4401   arg2 = (float)jarg2;
4402   {
4403     try {
4404       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4405     } catch (std::out_of_range& e) {
4406       {
4407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4408       };
4409     } catch (std::exception& e) {
4410       {
4411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4412       };
4413     } catch (...) {
4414       {
4415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4416       };
4417     }
4418   }
4419   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4420   return jresult;
4421 }
4422
4423
4424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4425   void * jresult ;
4426   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4427   Dali::Vector2 *arg2 = 0 ;
4428   Dali::Vector2 *result = 0 ;
4429
4430   arg1 = (Dali::Vector2 *)jarg1;
4431   arg2 = (Dali::Vector2 *)jarg2;
4432   if (!arg2) {
4433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4434     return 0;
4435   }
4436   {
4437     try {
4438       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4439     } catch (std::out_of_range& e) {
4440       {
4441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4442       };
4443     } catch (std::exception& e) {
4444       {
4445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4446       };
4447     } catch (...) {
4448       {
4449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4450       };
4451     }
4452   }
4453   jresult = (void *)result;
4454   return jresult;
4455 }
4456
4457
4458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4459   void * jresult ;
4460   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4461   float arg2 ;
4462   Dali::Vector2 *result = 0 ;
4463
4464   arg1 = (Dali::Vector2 *)jarg1;
4465   arg2 = (float)jarg2;
4466   {
4467     try {
4468       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4469     } catch (std::out_of_range& e) {
4470       {
4471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4472       };
4473     } catch (std::exception& e) {
4474       {
4475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4476       };
4477     } catch (...) {
4478       {
4479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4480       };
4481     }
4482   }
4483   jresult = (void *)result;
4484   return jresult;
4485 }
4486
4487
4488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4489   void * jresult ;
4490   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4491   Dali::Vector2 result;
4492
4493   arg1 = (Dali::Vector2 *)jarg1;
4494   {
4495     try {
4496       result = ((Dali::Vector2 const *)arg1)->operator -();
4497     } catch (std::out_of_range& e) {
4498       {
4499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4500       };
4501     } catch (std::exception& e) {
4502       {
4503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4504       };
4505     } catch (...) {
4506       {
4507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4508       };
4509     }
4510   }
4511   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4512   return jresult;
4513 }
4514
4515
4516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4517   unsigned int jresult ;
4518   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4519   Dali::Vector2 *arg2 = 0 ;
4520   bool result;
4521
4522   arg1 = (Dali::Vector2 *)jarg1;
4523   arg2 = (Dali::Vector2 *)jarg2;
4524   if (!arg2) {
4525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4526     return 0;
4527   }
4528   {
4529     try {
4530       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4531     } catch (std::out_of_range& e) {
4532       {
4533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4534       };
4535     } catch (std::exception& e) {
4536       {
4537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4538       };
4539     } catch (...) {
4540       {
4541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4542       };
4543     }
4544   }
4545   jresult = result;
4546   return jresult;
4547 }
4548
4549
4550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4551   unsigned int jresult ;
4552   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4553   Dali::Vector2 *arg2 = 0 ;
4554   bool result;
4555
4556   arg1 = (Dali::Vector2 *)jarg1;
4557   arg2 = (Dali::Vector2 *)jarg2;
4558   if (!arg2) {
4559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4560     return 0;
4561   }
4562   {
4563     try {
4564       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4565     } catch (std::out_of_range& e) {
4566       {
4567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4568       };
4569     } catch (std::exception& e) {
4570       {
4571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4572       };
4573     } catch (...) {
4574       {
4575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4576       };
4577     }
4578   }
4579   jresult = result;
4580   return jresult;
4581 }
4582
4583
4584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4585   float jresult ;
4586   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4587   unsigned int arg2 ;
4588   float *result = 0 ;
4589
4590   arg1 = (Dali::Vector2 *)jarg1;
4591   arg2 = (unsigned int)jarg2;
4592   {
4593     try {
4594       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4595     } catch (std::out_of_range& e) {
4596       {
4597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4598       };
4599     } catch (std::exception& e) {
4600       {
4601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4602       };
4603     } catch (...) {
4604       {
4605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4606       };
4607     }
4608   }
4609   jresult = *result;
4610   return jresult;
4611 }
4612
4613
4614 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4615   float jresult ;
4616   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4617   float result;
4618
4619   arg1 = (Dali::Vector2 *)jarg1;
4620   {
4621     try {
4622       result = (float)((Dali::Vector2 const *)arg1)->Length();
4623     } catch (std::out_of_range& e) {
4624       {
4625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4626       };
4627     } catch (std::exception& e) {
4628       {
4629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4630       };
4631     } catch (...) {
4632       {
4633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4634       };
4635     }
4636   }
4637   jresult = result;
4638   return jresult;
4639 }
4640
4641
4642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4643   float jresult ;
4644   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4645   float result;
4646
4647   arg1 = (Dali::Vector2 *)jarg1;
4648   {
4649     try {
4650       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4651     } catch (std::out_of_range& e) {
4652       {
4653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4654       };
4655     } catch (std::exception& e) {
4656       {
4657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4658       };
4659     } catch (...) {
4660       {
4661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4662       };
4663     }
4664   }
4665   jresult = result;
4666   return jresult;
4667 }
4668
4669
4670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4671   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4672
4673   arg1 = (Dali::Vector2 *)jarg1;
4674   {
4675     try {
4676       (arg1)->Normalize();
4677     } catch (std::out_of_range& e) {
4678       {
4679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4680       };
4681     } catch (std::exception& e) {
4682       {
4683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4684       };
4685     } catch (...) {
4686       {
4687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4688       };
4689     }
4690   }
4691 }
4692
4693
4694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4695   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4696   Dali::Vector2 *arg2 = 0 ;
4697   Dali::Vector2 *arg3 = 0 ;
4698
4699   arg1 = (Dali::Vector2 *)jarg1;
4700   arg2 = (Dali::Vector2 *)jarg2;
4701   if (!arg2) {
4702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4703     return ;
4704   }
4705   arg3 = (Dali::Vector2 *)jarg3;
4706   if (!arg3) {
4707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4708     return ;
4709   }
4710   {
4711     try {
4712       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4713     } catch (std::out_of_range& e) {
4714       {
4715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4716       };
4717     } catch (std::exception& e) {
4718       {
4719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4720       };
4721     } catch (...) {
4722       {
4723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4724       };
4725     }
4726   }
4727 }
4728
4729
4730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4731   void * jresult ;
4732   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4733   float *result = 0 ;
4734
4735   arg1 = (Dali::Vector2 *)jarg1;
4736   {
4737     try {
4738       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4739     } catch (std::out_of_range& e) {
4740       {
4741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4742       };
4743     } catch (std::exception& e) {
4744       {
4745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4746       };
4747     } catch (...) {
4748       {
4749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4750       };
4751     }
4752   }
4753   jresult = (void *)result;
4754   return jresult;
4755 }
4756
4757
4758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4759   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4760   float arg2 ;
4761
4762   arg1 = (Dali::Vector2 *)jarg1;
4763   arg2 = (float)jarg2;
4764   if (arg1) (arg1)->x = arg2;
4765 }
4766
4767
4768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4769   float jresult ;
4770   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4771   float result;
4772
4773   arg1 = (Dali::Vector2 *)jarg1;
4774   result = (float) ((arg1)->x);
4775   jresult = result;
4776   return jresult;
4777 }
4778
4779
4780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4781   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4782   float arg2 ;
4783
4784   arg1 = (Dali::Vector2 *)jarg1;
4785   arg2 = (float)jarg2;
4786   if (arg1) (arg1)->width = arg2;
4787 }
4788
4789
4790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4791   float jresult ;
4792   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4793   float result;
4794
4795   arg1 = (Dali::Vector2 *)jarg1;
4796   result = (float) ((arg1)->width);
4797   jresult = result;
4798   return jresult;
4799 }
4800
4801
4802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4803   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4804   float arg2 ;
4805
4806   arg1 = (Dali::Vector2 *)jarg1;
4807   arg2 = (float)jarg2;
4808   if (arg1) (arg1)->y = arg2;
4809 }
4810
4811
4812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4813   float jresult ;
4814   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4815   float result;
4816
4817   arg1 = (Dali::Vector2 *)jarg1;
4818   result = (float) ((arg1)->y);
4819   jresult = result;
4820   return jresult;
4821 }
4822
4823
4824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4825   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4826   float arg2 ;
4827
4828   arg1 = (Dali::Vector2 *)jarg1;
4829   arg2 = (float)jarg2;
4830   if (arg1) (arg1)->height = arg2;
4831 }
4832
4833
4834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4835   float jresult ;
4836   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4837   float result;
4838
4839   arg1 = (Dali::Vector2 *)jarg1;
4840   result = (float) ((arg1)->height);
4841   jresult = result;
4842   return jresult;
4843 }
4844
4845
4846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4847   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4848
4849   arg1 = (Dali::Vector2 *)jarg1;
4850   {
4851     try {
4852       delete arg1;
4853     } catch (std::out_of_range& e) {
4854       {
4855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4856       };
4857     } catch (std::exception& e) {
4858       {
4859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4860       };
4861     } catch (...) {
4862       {
4863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4864       };
4865     }
4866   }
4867 }
4868
4869
4870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4871   void * jresult ;
4872   Dali::Vector2 *arg1 = 0 ;
4873   Dali::Vector2 *arg2 = 0 ;
4874   Dali::Vector2 result;
4875
4876   arg1 = (Dali::Vector2 *)jarg1;
4877   if (!arg1) {
4878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4879     return 0;
4880   }
4881   arg2 = (Dali::Vector2 *)jarg2;
4882   if (!arg2) {
4883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4884     return 0;
4885   }
4886   {
4887     try {
4888       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4889     } catch (std::out_of_range& e) {
4890       {
4891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4892       };
4893     } catch (std::exception& e) {
4894       {
4895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4896       };
4897     } catch (...) {
4898       {
4899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4900       };
4901     }
4902   }
4903   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4904   return jresult;
4905 }
4906
4907
4908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4909   void * jresult ;
4910   Dali::Vector2 *arg1 = 0 ;
4911   Dali::Vector2 *arg2 = 0 ;
4912   Dali::Vector2 result;
4913
4914   arg1 = (Dali::Vector2 *)jarg1;
4915   if (!arg1) {
4916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4917     return 0;
4918   }
4919   arg2 = (Dali::Vector2 *)jarg2;
4920   if (!arg2) {
4921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4922     return 0;
4923   }
4924   {
4925     try {
4926       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4927     } catch (std::out_of_range& e) {
4928       {
4929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4930       };
4931     } catch (std::exception& e) {
4932       {
4933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4934       };
4935     } catch (...) {
4936       {
4937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4938       };
4939     }
4940   }
4941   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4942   return jresult;
4943 }
4944
4945
4946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4947   void * jresult ;
4948   Dali::Vector2 *arg1 = 0 ;
4949   float *arg2 = 0 ;
4950   float *arg3 = 0 ;
4951   float temp2 ;
4952   float temp3 ;
4953   Dali::Vector2 result;
4954
4955   arg1 = (Dali::Vector2 *)jarg1;
4956   if (!arg1) {
4957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4958     return 0;
4959   }
4960   temp2 = (float)jarg2;
4961   arg2 = &temp2;
4962   temp3 = (float)jarg3;
4963   arg3 = &temp3;
4964   {
4965     try {
4966       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4967     } catch (std::out_of_range& e) {
4968       {
4969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (std::exception& e) {
4972       {
4973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (...) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4978       };
4979     }
4980   }
4981   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4982   return jresult;
4983 }
4984
4985
4986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4987   void * jresult ;
4988   Dali::Vector3 *result = 0 ;
4989
4990   {
4991     try {
4992       result = (Dali::Vector3 *)new Dali::Vector3();
4993     } catch (std::out_of_range& e) {
4994       {
4995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4996       };
4997     } catch (std::exception& e) {
4998       {
4999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5000       };
5001     } catch (...) {
5002       {
5003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5004       };
5005     }
5006   }
5007   jresult = (void *)result;
5008   return jresult;
5009 }
5010
5011
5012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5013   void * jresult ;
5014   float arg1 ;
5015   float arg2 ;
5016   float arg3 ;
5017   Dali::Vector3 *result = 0 ;
5018
5019   arg1 = (float)jarg1;
5020   arg2 = (float)jarg2;
5021   arg3 = (float)jarg3;
5022   {
5023     try {
5024       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5025     } catch (std::out_of_range& e) {
5026       {
5027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5028       };
5029     } catch (std::exception& e) {
5030       {
5031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5032       };
5033     } catch (...) {
5034       {
5035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5036       };
5037     }
5038   }
5039   jresult = (void *)result;
5040   return jresult;
5041 }
5042
5043
5044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5045   void * jresult ;
5046   float *arg1 = (float *) 0 ;
5047   Dali::Vector3 *result = 0 ;
5048
5049   arg1 = jarg1;
5050   {
5051     try {
5052       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5053     } catch (std::out_of_range& e) {
5054       {
5055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5056       };
5057     } catch (std::exception& e) {
5058       {
5059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5060       };
5061     } catch (...) {
5062       {
5063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5064       };
5065     }
5066   }
5067   jresult = (void *)result;
5068
5069
5070   return jresult;
5071 }
5072
5073
5074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5075   void * jresult ;
5076   Dali::Vector2 *arg1 = 0 ;
5077   Dali::Vector3 *result = 0 ;
5078
5079   arg1 = (Dali::Vector2 *)jarg1;
5080   if (!arg1) {
5081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5082     return 0;
5083   }
5084   {
5085     try {
5086       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5087     } catch (std::out_of_range& e) {
5088       {
5089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5090       };
5091     } catch (std::exception& e) {
5092       {
5093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5094       };
5095     } catch (...) {
5096       {
5097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5098       };
5099     }
5100   }
5101   jresult = (void *)result;
5102   return jresult;
5103 }
5104
5105
5106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5107   void * jresult ;
5108   Dali::Vector4 *arg1 = 0 ;
5109   Dali::Vector3 *result = 0 ;
5110
5111   arg1 = (Dali::Vector4 *)jarg1;
5112   if (!arg1) {
5113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5114     return 0;
5115   }
5116   {
5117     try {
5118       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5119     } catch (std::out_of_range& e) {
5120       {
5121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5122       };
5123     } catch (std::exception& e) {
5124       {
5125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5126       };
5127     } catch (...) {
5128       {
5129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5130       };
5131     }
5132   }
5133   jresult = (void *)result;
5134   return jresult;
5135 }
5136
5137
5138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5139   void * jresult ;
5140   Dali::Vector3 *result = 0 ;
5141
5142   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5143   jresult = (void *)result;
5144   return jresult;
5145 }
5146
5147
5148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5149   void * jresult ;
5150   Dali::Vector3 *result = 0 ;
5151
5152   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5153   jresult = (void *)result;
5154   return jresult;
5155 }
5156
5157
5158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5159   void * jresult ;
5160   Dali::Vector3 *result = 0 ;
5161
5162   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5163   jresult = (void *)result;
5164   return jresult;
5165 }
5166
5167
5168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5169   void * jresult ;
5170   Dali::Vector3 *result = 0 ;
5171
5172   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5173   jresult = (void *)result;
5174   return jresult;
5175 }
5176
5177
5178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5179   void * jresult ;
5180   Dali::Vector3 *result = 0 ;
5181
5182   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5183   jresult = (void *)result;
5184   return jresult;
5185 }
5186
5187
5188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5189   void * jresult ;
5190   Dali::Vector3 *result = 0 ;
5191
5192   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5193   jresult = (void *)result;
5194   return jresult;
5195 }
5196
5197
5198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5199   void * jresult ;
5200   Dali::Vector3 *result = 0 ;
5201
5202   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5203   jresult = (void *)result;
5204   return jresult;
5205 }
5206
5207
5208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5209   void * jresult ;
5210   Dali::Vector3 *result = 0 ;
5211
5212   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5213   jresult = (void *)result;
5214   return jresult;
5215 }
5216
5217
5218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5219   void * jresult ;
5220   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5221   float *arg2 = (float *) 0 ;
5222   Dali::Vector3 *result = 0 ;
5223
5224   arg1 = (Dali::Vector3 *)jarg1;
5225   arg2 = jarg2;
5226   {
5227     try {
5228       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5229     } catch (std::out_of_range& e) {
5230       {
5231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5232       };
5233     } catch (std::exception& e) {
5234       {
5235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5236       };
5237     } catch (...) {
5238       {
5239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5240       };
5241     }
5242   }
5243   jresult = (void *)result;
5244
5245
5246   return jresult;
5247 }
5248
5249
5250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5251   void * jresult ;
5252   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5253   Dali::Vector2 *arg2 = 0 ;
5254   Dali::Vector3 *result = 0 ;
5255
5256   arg1 = (Dali::Vector3 *)jarg1;
5257   arg2 = (Dali::Vector2 *)jarg2;
5258   if (!arg2) {
5259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5260     return 0;
5261   }
5262   {
5263     try {
5264       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5265     } catch (std::out_of_range& e) {
5266       {
5267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5268       };
5269     } catch (std::exception& e) {
5270       {
5271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5272       };
5273     } catch (...) {
5274       {
5275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5276       };
5277     }
5278   }
5279   jresult = (void *)result;
5280   return jresult;
5281 }
5282
5283
5284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5285   void * jresult ;
5286   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5287   Dali::Vector4 *arg2 = 0 ;
5288   Dali::Vector3 *result = 0 ;
5289
5290   arg1 = (Dali::Vector3 *)jarg1;
5291   arg2 = (Dali::Vector4 *)jarg2;
5292   if (!arg2) {
5293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5294     return 0;
5295   }
5296   {
5297     try {
5298       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5299     } catch (std::out_of_range& e) {
5300       {
5301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5302       };
5303     } catch (std::exception& e) {
5304       {
5305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5306       };
5307     } catch (...) {
5308       {
5309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5310       };
5311     }
5312   }
5313   jresult = (void *)result;
5314   return jresult;
5315 }
5316
5317
5318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5319   void * jresult ;
5320   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5321   Dali::Vector3 *arg2 = 0 ;
5322   Dali::Vector3 result;
5323
5324   arg1 = (Dali::Vector3 *)jarg1;
5325   arg2 = (Dali::Vector3 *)jarg2;
5326   if (!arg2) {
5327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5328     return 0;
5329   }
5330   {
5331     try {
5332       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5333     } catch (std::out_of_range& e) {
5334       {
5335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5336       };
5337     } catch (std::exception& e) {
5338       {
5339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5340       };
5341     } catch (...) {
5342       {
5343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5344       };
5345     }
5346   }
5347   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5348   return jresult;
5349 }
5350
5351
5352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5353   void * jresult ;
5354   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5355   Dali::Vector3 *arg2 = 0 ;
5356   Dali::Vector3 *result = 0 ;
5357
5358   arg1 = (Dali::Vector3 *)jarg1;
5359   arg2 = (Dali::Vector3 *)jarg2;
5360   if (!arg2) {
5361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5362     return 0;
5363   }
5364   {
5365     try {
5366       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5367     } catch (std::out_of_range& e) {
5368       {
5369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5370       };
5371     } catch (std::exception& e) {
5372       {
5373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5374       };
5375     } catch (...) {
5376       {
5377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5378       };
5379     }
5380   }
5381   jresult = (void *)result;
5382   return jresult;
5383 }
5384
5385
5386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5387   void * jresult ;
5388   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5389   Dali::Vector3 *arg2 = 0 ;
5390   Dali::Vector3 result;
5391
5392   arg1 = (Dali::Vector3 *)jarg1;
5393   arg2 = (Dali::Vector3 *)jarg2;
5394   if (!arg2) {
5395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5396     return 0;
5397   }
5398   {
5399     try {
5400       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5401     } catch (std::out_of_range& e) {
5402       {
5403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5404       };
5405     } catch (std::exception& e) {
5406       {
5407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5408       };
5409     } catch (...) {
5410       {
5411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5412       };
5413     }
5414   }
5415   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5416   return jresult;
5417 }
5418
5419
5420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5421   void * jresult ;
5422   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5423   Dali::Vector3 *arg2 = 0 ;
5424   Dali::Vector3 *result = 0 ;
5425
5426   arg1 = (Dali::Vector3 *)jarg1;
5427   arg2 = (Dali::Vector3 *)jarg2;
5428   if (!arg2) {
5429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5430     return 0;
5431   }
5432   {
5433     try {
5434       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5435     } catch (std::out_of_range& e) {
5436       {
5437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5438       };
5439     } catch (std::exception& e) {
5440       {
5441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5442       };
5443     } catch (...) {
5444       {
5445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5446       };
5447     }
5448   }
5449   jresult = (void *)result;
5450   return jresult;
5451 }
5452
5453
5454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5455   void * jresult ;
5456   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5457   Dali::Vector3 *arg2 = 0 ;
5458   Dali::Vector3 result;
5459
5460   arg1 = (Dali::Vector3 *)jarg1;
5461   arg2 = (Dali::Vector3 *)jarg2;
5462   if (!arg2) {
5463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5464     return 0;
5465   }
5466   {
5467     try {
5468       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5469     } catch (std::out_of_range& e) {
5470       {
5471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5472       };
5473     } catch (std::exception& e) {
5474       {
5475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5476       };
5477     } catch (...) {
5478       {
5479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5480       };
5481     }
5482   }
5483   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5484   return jresult;
5485 }
5486
5487
5488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5489   void * jresult ;
5490   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5491   float arg2 ;
5492   Dali::Vector3 result;
5493
5494   arg1 = (Dali::Vector3 *)jarg1;
5495   arg2 = (float)jarg2;
5496   {
5497     try {
5498       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5499     } catch (std::out_of_range& e) {
5500       {
5501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5502       };
5503     } catch (std::exception& e) {
5504       {
5505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5506       };
5507     } catch (...) {
5508       {
5509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5510       };
5511     }
5512   }
5513   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5514   return jresult;
5515 }
5516
5517
5518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5519   void * jresult ;
5520   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5521   Dali::Vector3 *arg2 = 0 ;
5522   Dali::Vector3 *result = 0 ;
5523
5524   arg1 = (Dali::Vector3 *)jarg1;
5525   arg2 = (Dali::Vector3 *)jarg2;
5526   if (!arg2) {
5527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5528     return 0;
5529   }
5530   {
5531     try {
5532       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5533     } catch (std::out_of_range& e) {
5534       {
5535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5536       };
5537     } catch (std::exception& e) {
5538       {
5539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5540       };
5541     } catch (...) {
5542       {
5543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5544       };
5545     }
5546   }
5547   jresult = (void *)result;
5548   return jresult;
5549 }
5550
5551
5552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5553   void * jresult ;
5554   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5555   float arg2 ;
5556   Dali::Vector3 *result = 0 ;
5557
5558   arg1 = (Dali::Vector3 *)jarg1;
5559   arg2 = (float)jarg2;
5560   {
5561     try {
5562       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5563     } catch (std::out_of_range& e) {
5564       {
5565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (std::exception& e) {
5568       {
5569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (...) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5574       };
5575     }
5576   }
5577   jresult = (void *)result;
5578   return jresult;
5579 }
5580
5581
5582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5583   void * jresult ;
5584   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5585   Dali::Quaternion *arg2 = 0 ;
5586   Dali::Vector3 *result = 0 ;
5587
5588   arg1 = (Dali::Vector3 *)jarg1;
5589   arg2 = (Dali::Quaternion *)jarg2;
5590   if (!arg2) {
5591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5592     return 0;
5593   }
5594   {
5595     try {
5596       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5597     } catch (std::out_of_range& e) {
5598       {
5599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5600       };
5601     } catch (std::exception& e) {
5602       {
5603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5604       };
5605     } catch (...) {
5606       {
5607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5608       };
5609     }
5610   }
5611   jresult = (void *)result;
5612   return jresult;
5613 }
5614
5615
5616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5617   void * jresult ;
5618   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5619   Dali::Vector3 *arg2 = 0 ;
5620   Dali::Vector3 result;
5621
5622   arg1 = (Dali::Vector3 *)jarg1;
5623   arg2 = (Dali::Vector3 *)jarg2;
5624   if (!arg2) {
5625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5626     return 0;
5627   }
5628   {
5629     try {
5630       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5631     } catch (std::out_of_range& e) {
5632       {
5633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5634       };
5635     } catch (std::exception& e) {
5636       {
5637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5638       };
5639     } catch (...) {
5640       {
5641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5642       };
5643     }
5644   }
5645   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5646   return jresult;
5647 }
5648
5649
5650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5651   void * jresult ;
5652   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5653   float arg2 ;
5654   Dali::Vector3 result;
5655
5656   arg1 = (Dali::Vector3 *)jarg1;
5657   arg2 = (float)jarg2;
5658   {
5659     try {
5660       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5661     } catch (std::out_of_range& e) {
5662       {
5663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5664       };
5665     } catch (std::exception& e) {
5666       {
5667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5668       };
5669     } catch (...) {
5670       {
5671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5672       };
5673     }
5674   }
5675   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5676   return jresult;
5677 }
5678
5679
5680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5681   void * jresult ;
5682   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5683   Dali::Vector3 *arg2 = 0 ;
5684   Dali::Vector3 *result = 0 ;
5685
5686   arg1 = (Dali::Vector3 *)jarg1;
5687   arg2 = (Dali::Vector3 *)jarg2;
5688   if (!arg2) {
5689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5690     return 0;
5691   }
5692   {
5693     try {
5694       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5695     } catch (std::out_of_range& e) {
5696       {
5697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5698       };
5699     } catch (std::exception& e) {
5700       {
5701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5702       };
5703     } catch (...) {
5704       {
5705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5706       };
5707     }
5708   }
5709   jresult = (void *)result;
5710   return jresult;
5711 }
5712
5713
5714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5715   void * jresult ;
5716   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5717   float arg2 ;
5718   Dali::Vector3 *result = 0 ;
5719
5720   arg1 = (Dali::Vector3 *)jarg1;
5721   arg2 = (float)jarg2;
5722   {
5723     try {
5724       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5725     } catch (std::out_of_range& e) {
5726       {
5727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5728       };
5729     } catch (std::exception& e) {
5730       {
5731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5732       };
5733     } catch (...) {
5734       {
5735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5736       };
5737     }
5738   }
5739   jresult = (void *)result;
5740   return jresult;
5741 }
5742
5743
5744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5745   void * jresult ;
5746   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5747   Dali::Vector3 result;
5748
5749   arg1 = (Dali::Vector3 *)jarg1;
5750   {
5751     try {
5752       result = ((Dali::Vector3 const *)arg1)->operator -();
5753     } catch (std::out_of_range& e) {
5754       {
5755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5756       };
5757     } catch (std::exception& e) {
5758       {
5759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5760       };
5761     } catch (...) {
5762       {
5763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5764       };
5765     }
5766   }
5767   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5768   return jresult;
5769 }
5770
5771
5772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5773   unsigned int jresult ;
5774   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5775   Dali::Vector3 *arg2 = 0 ;
5776   bool result;
5777
5778   arg1 = (Dali::Vector3 *)jarg1;
5779   arg2 = (Dali::Vector3 *)jarg2;
5780   if (!arg2) {
5781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5782     return 0;
5783   }
5784   {
5785     try {
5786       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5787     } catch (std::out_of_range& e) {
5788       {
5789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5790       };
5791     } catch (std::exception& e) {
5792       {
5793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5794       };
5795     } catch (...) {
5796       {
5797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5798       };
5799     }
5800   }
5801   jresult = result;
5802   return jresult;
5803 }
5804
5805
5806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5807   unsigned int jresult ;
5808   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5809   Dali::Vector3 *arg2 = 0 ;
5810   bool result;
5811
5812   arg1 = (Dali::Vector3 *)jarg1;
5813   arg2 = (Dali::Vector3 *)jarg2;
5814   if (!arg2) {
5815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5816     return 0;
5817   }
5818   {
5819     try {
5820       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5821     } catch (std::out_of_range& e) {
5822       {
5823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5824       };
5825     } catch (std::exception& e) {
5826       {
5827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5828       };
5829     } catch (...) {
5830       {
5831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5832       };
5833     }
5834   }
5835   jresult = result;
5836   return jresult;
5837 }
5838
5839
5840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5841   float jresult ;
5842   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5843   unsigned int arg2 ;
5844   float *result = 0 ;
5845
5846   arg1 = (Dali::Vector3 *)jarg1;
5847   arg2 = (unsigned int)jarg2;
5848   {
5849     try {
5850       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5851     } catch (std::out_of_range& e) {
5852       {
5853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5854       };
5855     } catch (std::exception& e) {
5856       {
5857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (...) {
5860       {
5861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5862       };
5863     }
5864   }
5865   jresult = *result;
5866   return jresult;
5867 }
5868
5869
5870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5871   float jresult ;
5872   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5873   Dali::Vector3 *arg2 = 0 ;
5874   float result;
5875
5876   arg1 = (Dali::Vector3 *)jarg1;
5877   arg2 = (Dali::Vector3 *)jarg2;
5878   if (!arg2) {
5879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5880     return 0;
5881   }
5882   {
5883     try {
5884       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5885     } catch (std::out_of_range& e) {
5886       {
5887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5888       };
5889     } catch (std::exception& e) {
5890       {
5891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5892       };
5893     } catch (...) {
5894       {
5895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5896       };
5897     }
5898   }
5899   jresult = result;
5900   return jresult;
5901 }
5902
5903
5904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5905   void * jresult ;
5906   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5907   Dali::Vector3 *arg2 = 0 ;
5908   Dali::Vector3 result;
5909
5910   arg1 = (Dali::Vector3 *)jarg1;
5911   arg2 = (Dali::Vector3 *)jarg2;
5912   if (!arg2) {
5913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5914     return 0;
5915   }
5916   {
5917     try {
5918       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5919     } catch (std::out_of_range& e) {
5920       {
5921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5922       };
5923     } catch (std::exception& e) {
5924       {
5925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5926       };
5927     } catch (...) {
5928       {
5929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5930       };
5931     }
5932   }
5933   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5934   return jresult;
5935 }
5936
5937
5938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5939   float jresult ;
5940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5941   float result;
5942
5943   arg1 = (Dali::Vector3 *)jarg1;
5944   {
5945     try {
5946       result = (float)((Dali::Vector3 const *)arg1)->Length();
5947     } catch (std::out_of_range& e) {
5948       {
5949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5950       };
5951     } catch (std::exception& e) {
5952       {
5953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5954       };
5955     } catch (...) {
5956       {
5957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5958       };
5959     }
5960   }
5961   jresult = result;
5962   return jresult;
5963 }
5964
5965
5966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5967   float jresult ;
5968   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5969   float result;
5970
5971   arg1 = (Dali::Vector3 *)jarg1;
5972   {
5973     try {
5974       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5975     } catch (std::out_of_range& e) {
5976       {
5977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5978       };
5979     } catch (std::exception& e) {
5980       {
5981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5982       };
5983     } catch (...) {
5984       {
5985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5986       };
5987     }
5988   }
5989   jresult = result;
5990   return jresult;
5991 }
5992
5993
5994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
5995   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5996
5997   arg1 = (Dali::Vector3 *)jarg1;
5998   {
5999     try {
6000       (arg1)->Normalize();
6001     } catch (std::out_of_range& e) {
6002       {
6003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6004       };
6005     } catch (std::exception& e) {
6006       {
6007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6008       };
6009     } catch (...) {
6010       {
6011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6012       };
6013     }
6014   }
6015 }
6016
6017
6018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6019   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6020   Dali::Vector3 *arg2 = 0 ;
6021   Dali::Vector3 *arg3 = 0 ;
6022
6023   arg1 = (Dali::Vector3 *)jarg1;
6024   arg2 = (Dali::Vector3 *)jarg2;
6025   if (!arg2) {
6026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6027     return ;
6028   }
6029   arg3 = (Dali::Vector3 *)jarg3;
6030   if (!arg3) {
6031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6032     return ;
6033   }
6034   {
6035     try {
6036       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6037     } catch (std::out_of_range& e) {
6038       {
6039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6040       };
6041     } catch (std::exception& e) {
6042       {
6043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6044       };
6045     } catch (...) {
6046       {
6047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6048       };
6049     }
6050   }
6051 }
6052
6053
6054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6055   void * jresult ;
6056   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6057   float *result = 0 ;
6058
6059   arg1 = (Dali::Vector3 *)jarg1;
6060   {
6061     try {
6062       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6063     } catch (std::out_of_range& e) {
6064       {
6065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6066       };
6067     } catch (std::exception& e) {
6068       {
6069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6070       };
6071     } catch (...) {
6072       {
6073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6074       };
6075     }
6076   }
6077   jresult = (void *)result;
6078   return jresult;
6079 }
6080
6081
6082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6083   void * jresult ;
6084   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6085   Dali::Vector2 *result = 0 ;
6086
6087   arg1 = (Dali::Vector3 *)jarg1;
6088   {
6089     try {
6090       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6091     } catch (std::out_of_range& e) {
6092       {
6093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6094       };
6095     } catch (std::exception& e) {
6096       {
6097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6098       };
6099     } catch (...) {
6100       {
6101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6102       };
6103     }
6104   }
6105   jresult = (void *)result;
6106   return jresult;
6107 }
6108
6109
6110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6111   void * jresult ;
6112   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6113   Dali::Vector2 *result = 0 ;
6114
6115   arg1 = (Dali::Vector3 *)jarg1;
6116   {
6117     try {
6118       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6119     } catch (std::out_of_range& e) {
6120       {
6121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6122       };
6123     } catch (std::exception& e) {
6124       {
6125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6126       };
6127     } catch (...) {
6128       {
6129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6130       };
6131     }
6132   }
6133   jresult = (void *)result;
6134   return jresult;
6135 }
6136
6137
6138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6139   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6140   float arg2 ;
6141
6142   arg1 = (Dali::Vector3 *)jarg1;
6143   arg2 = (float)jarg2;
6144   if (arg1) (arg1)->x = arg2;
6145 }
6146
6147
6148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6149   float jresult ;
6150   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6151   float result;
6152
6153   arg1 = (Dali::Vector3 *)jarg1;
6154   result = (float) ((arg1)->x);
6155   jresult = result;
6156   return jresult;
6157 }
6158
6159
6160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6161   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6162   float arg2 ;
6163
6164   arg1 = (Dali::Vector3 *)jarg1;
6165   arg2 = (float)jarg2;
6166   if (arg1) (arg1)->width = arg2;
6167 }
6168
6169
6170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6171   float jresult ;
6172   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6173   float result;
6174
6175   arg1 = (Dali::Vector3 *)jarg1;
6176   result = (float) ((arg1)->width);
6177   jresult = result;
6178   return jresult;
6179 }
6180
6181
6182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6183   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6184   float arg2 ;
6185
6186   arg1 = (Dali::Vector3 *)jarg1;
6187   arg2 = (float)jarg2;
6188   if (arg1) (arg1)->r = arg2;
6189 }
6190
6191
6192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6193   float jresult ;
6194   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6195   float result;
6196
6197   arg1 = (Dali::Vector3 *)jarg1;
6198   result = (float) ((arg1)->r);
6199   jresult = result;
6200   return jresult;
6201 }
6202
6203
6204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6205   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6206   float arg2 ;
6207
6208   arg1 = (Dali::Vector3 *)jarg1;
6209   arg2 = (float)jarg2;
6210   if (arg1) (arg1)->y = arg2;
6211 }
6212
6213
6214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6215   float jresult ;
6216   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6217   float result;
6218
6219   arg1 = (Dali::Vector3 *)jarg1;
6220   result = (float) ((arg1)->y);
6221   jresult = result;
6222   return jresult;
6223 }
6224
6225
6226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6227   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6228   float arg2 ;
6229
6230   arg1 = (Dali::Vector3 *)jarg1;
6231   arg2 = (float)jarg2;
6232   if (arg1) (arg1)->height = arg2;
6233 }
6234
6235
6236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6237   float jresult ;
6238   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6239   float result;
6240
6241   arg1 = (Dali::Vector3 *)jarg1;
6242   result = (float) ((arg1)->height);
6243   jresult = result;
6244   return jresult;
6245 }
6246
6247
6248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6249   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6250   float arg2 ;
6251
6252   arg1 = (Dali::Vector3 *)jarg1;
6253   arg2 = (float)jarg2;
6254   if (arg1) (arg1)->g = arg2;
6255 }
6256
6257
6258 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6259   float jresult ;
6260   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6261   float result;
6262
6263   arg1 = (Dali::Vector3 *)jarg1;
6264   result = (float) ((arg1)->g);
6265   jresult = result;
6266   return jresult;
6267 }
6268
6269
6270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6271   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6272   float arg2 ;
6273
6274   arg1 = (Dali::Vector3 *)jarg1;
6275   arg2 = (float)jarg2;
6276   if (arg1) (arg1)->z = arg2;
6277 }
6278
6279
6280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6281   float jresult ;
6282   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6283   float result;
6284
6285   arg1 = (Dali::Vector3 *)jarg1;
6286   result = (float) ((arg1)->z);
6287   jresult = result;
6288   return jresult;
6289 }
6290
6291
6292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6293   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6294   float arg2 ;
6295
6296   arg1 = (Dali::Vector3 *)jarg1;
6297   arg2 = (float)jarg2;
6298   if (arg1) (arg1)->depth = arg2;
6299 }
6300
6301
6302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6303   float jresult ;
6304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6305   float result;
6306
6307   arg1 = (Dali::Vector3 *)jarg1;
6308   result = (float) ((arg1)->depth);
6309   jresult = result;
6310   return jresult;
6311 }
6312
6313
6314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6315   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6316   float arg2 ;
6317
6318   arg1 = (Dali::Vector3 *)jarg1;
6319   arg2 = (float)jarg2;
6320   if (arg1) (arg1)->b = arg2;
6321 }
6322
6323
6324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6325   float jresult ;
6326   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6327   float result;
6328
6329   arg1 = (Dali::Vector3 *)jarg1;
6330   result = (float) ((arg1)->b);
6331   jresult = result;
6332   return jresult;
6333 }
6334
6335
6336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6337   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6338
6339   arg1 = (Dali::Vector3 *)jarg1;
6340   {
6341     try {
6342       delete arg1;
6343     } catch (std::out_of_range& e) {
6344       {
6345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6346       };
6347     } catch (std::exception& e) {
6348       {
6349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6350       };
6351     } catch (...) {
6352       {
6353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6354       };
6355     }
6356   }
6357 }
6358
6359
6360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6361   void * jresult ;
6362   Dali::Vector3 *arg1 = 0 ;
6363   Dali::Vector3 *arg2 = 0 ;
6364   Dali::Vector3 result;
6365
6366   arg1 = (Dali::Vector3 *)jarg1;
6367   if (!arg1) {
6368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6369     return 0;
6370   }
6371   arg2 = (Dali::Vector3 *)jarg2;
6372   if (!arg2) {
6373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6374     return 0;
6375   }
6376   {
6377     try {
6378       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6379     } catch (std::out_of_range& e) {
6380       {
6381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6382       };
6383     } catch (std::exception& e) {
6384       {
6385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6386       };
6387     } catch (...) {
6388       {
6389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6390       };
6391     }
6392   }
6393   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6394   return jresult;
6395 }
6396
6397
6398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6399   void * jresult ;
6400   Dali::Vector3 *arg1 = 0 ;
6401   Dali::Vector3 *arg2 = 0 ;
6402   Dali::Vector3 result;
6403
6404   arg1 = (Dali::Vector3 *)jarg1;
6405   if (!arg1) {
6406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6407     return 0;
6408   }
6409   arg2 = (Dali::Vector3 *)jarg2;
6410   if (!arg2) {
6411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6412     return 0;
6413   }
6414   {
6415     try {
6416       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6417     } catch (std::out_of_range& e) {
6418       {
6419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6420       };
6421     } catch (std::exception& e) {
6422       {
6423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6424       };
6425     } catch (...) {
6426       {
6427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6428       };
6429     }
6430   }
6431   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6432   return jresult;
6433 }
6434
6435
6436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6437   void * jresult ;
6438   Dali::Vector3 *arg1 = 0 ;
6439   float *arg2 = 0 ;
6440   float *arg3 = 0 ;
6441   float temp2 ;
6442   float temp3 ;
6443   Dali::Vector3 result;
6444
6445   arg1 = (Dali::Vector3 *)jarg1;
6446   if (!arg1) {
6447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6448     return 0;
6449   }
6450   temp2 = (float)jarg2;
6451   arg2 = &temp2;
6452   temp3 = (float)jarg3;
6453   arg3 = &temp3;
6454   {
6455     try {
6456       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6457     } catch (std::out_of_range& e) {
6458       {
6459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6460       };
6461     } catch (std::exception& e) {
6462       {
6463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (...) {
6466       {
6467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6468       };
6469     }
6470   }
6471   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6472   return jresult;
6473 }
6474
6475
6476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6477   void * jresult ;
6478   Dali::Vector4 *result = 0 ;
6479
6480   {
6481     try {
6482       result = (Dali::Vector4 *)new Dali::Vector4();
6483     } catch (std::out_of_range& e) {
6484       {
6485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6486       };
6487     } catch (std::exception& e) {
6488       {
6489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6490       };
6491     } catch (...) {
6492       {
6493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6494       };
6495     }
6496   }
6497   jresult = (void *)result;
6498   return jresult;
6499 }
6500
6501
6502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6503   void * jresult ;
6504   float arg1 ;
6505   float arg2 ;
6506   float arg3 ;
6507   float arg4 ;
6508   Dali::Vector4 *result = 0 ;
6509
6510   arg1 = (float)jarg1;
6511   arg2 = (float)jarg2;
6512   arg3 = (float)jarg3;
6513   arg4 = (float)jarg4;
6514   {
6515     try {
6516       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6517     } catch (std::out_of_range& e) {
6518       {
6519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6520       };
6521     } catch (std::exception& e) {
6522       {
6523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6524       };
6525     } catch (...) {
6526       {
6527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6528       };
6529     }
6530   }
6531   jresult = (void *)result;
6532   return jresult;
6533 }
6534
6535
6536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6537   void * jresult ;
6538   float *arg1 = (float *) 0 ;
6539   Dali::Vector4 *result = 0 ;
6540
6541   arg1 = jarg1;
6542   {
6543     try {
6544       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6545     } catch (std::out_of_range& e) {
6546       {
6547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6548       };
6549     } catch (std::exception& e) {
6550       {
6551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6552       };
6553     } catch (...) {
6554       {
6555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6556       };
6557     }
6558   }
6559   jresult = (void *)result;
6560
6561
6562   return jresult;
6563 }
6564
6565
6566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6567   void * jresult ;
6568   Dali::Vector2 *arg1 = 0 ;
6569   Dali::Vector4 *result = 0 ;
6570
6571   arg1 = (Dali::Vector2 *)jarg1;
6572   if (!arg1) {
6573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6574     return 0;
6575   }
6576   {
6577     try {
6578       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6579     } catch (std::out_of_range& e) {
6580       {
6581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6582       };
6583     } catch (std::exception& e) {
6584       {
6585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6586       };
6587     } catch (...) {
6588       {
6589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6590       };
6591     }
6592   }
6593   jresult = (void *)result;
6594   return jresult;
6595 }
6596
6597
6598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6599   void * jresult ;
6600   Dali::Vector3 *arg1 = 0 ;
6601   Dali::Vector4 *result = 0 ;
6602
6603   arg1 = (Dali::Vector3 *)jarg1;
6604   if (!arg1) {
6605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6606     return 0;
6607   }
6608   {
6609     try {
6610       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6611     } catch (std::out_of_range& e) {
6612       {
6613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6614       };
6615     } catch (std::exception& e) {
6616       {
6617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6618       };
6619     } catch (...) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6622       };
6623     }
6624   }
6625   jresult = (void *)result;
6626   return jresult;
6627 }
6628
6629
6630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6631   void * jresult ;
6632   Dali::Vector4 *result = 0 ;
6633
6634   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6635   jresult = (void *)result;
6636   return jresult;
6637 }
6638
6639
6640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6641   void * jresult ;
6642   Dali::Vector4 *result = 0 ;
6643
6644   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6645   jresult = (void *)result;
6646   return jresult;
6647 }
6648
6649
6650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6651   void * jresult ;
6652   Dali::Vector4 *result = 0 ;
6653
6654   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6655   jresult = (void *)result;
6656   return jresult;
6657 }
6658
6659
6660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6661   void * jresult ;
6662   Dali::Vector4 *result = 0 ;
6663
6664   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6665   jresult = (void *)result;
6666   return jresult;
6667 }
6668
6669
6670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6671   void * jresult ;
6672   Dali::Vector4 *result = 0 ;
6673
6674   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6675   jresult = (void *)result;
6676   return jresult;
6677 }
6678
6679
6680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6681   void * jresult ;
6682   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6683   float *arg2 = (float *) 0 ;
6684   Dali::Vector4 *result = 0 ;
6685
6686   arg1 = (Dali::Vector4 *)jarg1;
6687   arg2 = jarg2;
6688   {
6689     try {
6690       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6691     } catch (std::out_of_range& e) {
6692       {
6693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6694       };
6695     } catch (std::exception& e) {
6696       {
6697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6698       };
6699     } catch (...) {
6700       {
6701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6702       };
6703     }
6704   }
6705   jresult = (void *)result;
6706
6707
6708   return jresult;
6709 }
6710
6711
6712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6713   void * jresult ;
6714   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6715   Dali::Vector2 *arg2 = 0 ;
6716   Dali::Vector4 *result = 0 ;
6717
6718   arg1 = (Dali::Vector4 *)jarg1;
6719   arg2 = (Dali::Vector2 *)jarg2;
6720   if (!arg2) {
6721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6722     return 0;
6723   }
6724   {
6725     try {
6726       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6727     } catch (std::out_of_range& e) {
6728       {
6729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6730       };
6731     } catch (std::exception& e) {
6732       {
6733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6734       };
6735     } catch (...) {
6736       {
6737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6738       };
6739     }
6740   }
6741   jresult = (void *)result;
6742   return jresult;
6743 }
6744
6745
6746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6747   void * jresult ;
6748   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6749   Dali::Vector3 *arg2 = 0 ;
6750   Dali::Vector4 *result = 0 ;
6751
6752   arg1 = (Dali::Vector4 *)jarg1;
6753   arg2 = (Dali::Vector3 *)jarg2;
6754   if (!arg2) {
6755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6756     return 0;
6757   }
6758   {
6759     try {
6760       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6761     } catch (std::out_of_range& e) {
6762       {
6763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6764       };
6765     } catch (std::exception& e) {
6766       {
6767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6768       };
6769     } catch (...) {
6770       {
6771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6772       };
6773     }
6774   }
6775   jresult = (void *)result;
6776   return jresult;
6777 }
6778
6779
6780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6781   void * jresult ;
6782   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6783   Dali::Vector4 *arg2 = 0 ;
6784   Dali::Vector4 result;
6785
6786   arg1 = (Dali::Vector4 *)jarg1;
6787   arg2 = (Dali::Vector4 *)jarg2;
6788   if (!arg2) {
6789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6790     return 0;
6791   }
6792   {
6793     try {
6794       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6795     } catch (std::out_of_range& e) {
6796       {
6797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6798       };
6799     } catch (std::exception& e) {
6800       {
6801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6802       };
6803     } catch (...) {
6804       {
6805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6806       };
6807     }
6808   }
6809   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6810   return jresult;
6811 }
6812
6813
6814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6815   void * jresult ;
6816   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6817   Dali::Vector4 *arg2 = 0 ;
6818   Dali::Vector4 *result = 0 ;
6819
6820   arg1 = (Dali::Vector4 *)jarg1;
6821   arg2 = (Dali::Vector4 *)jarg2;
6822   if (!arg2) {
6823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6824     return 0;
6825   }
6826   {
6827     try {
6828       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6829     } catch (std::out_of_range& e) {
6830       {
6831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6832       };
6833     } catch (std::exception& e) {
6834       {
6835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6836       };
6837     } catch (...) {
6838       {
6839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6840       };
6841     }
6842   }
6843   jresult = (void *)result;
6844   return jresult;
6845 }
6846
6847
6848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6849   void * jresult ;
6850   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6851   Dali::Vector4 *arg2 = 0 ;
6852   Dali::Vector4 result;
6853
6854   arg1 = (Dali::Vector4 *)jarg1;
6855   arg2 = (Dali::Vector4 *)jarg2;
6856   if (!arg2) {
6857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6858     return 0;
6859   }
6860   {
6861     try {
6862       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6863     } catch (std::out_of_range& e) {
6864       {
6865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6866       };
6867     } catch (std::exception& e) {
6868       {
6869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6870       };
6871     } catch (...) {
6872       {
6873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6874       };
6875     }
6876   }
6877   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6878   return jresult;
6879 }
6880
6881
6882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6883   void * jresult ;
6884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6885   Dali::Vector4 *arg2 = 0 ;
6886   Dali::Vector4 *result = 0 ;
6887
6888   arg1 = (Dali::Vector4 *)jarg1;
6889   arg2 = (Dali::Vector4 *)jarg2;
6890   if (!arg2) {
6891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6892     return 0;
6893   }
6894   {
6895     try {
6896       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6897     } catch (std::out_of_range& e) {
6898       {
6899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6900       };
6901     } catch (std::exception& e) {
6902       {
6903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6904       };
6905     } catch (...) {
6906       {
6907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6908       };
6909     }
6910   }
6911   jresult = (void *)result;
6912   return jresult;
6913 }
6914
6915
6916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6917   void * jresult ;
6918   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6919   Dali::Vector4 *arg2 = 0 ;
6920   Dali::Vector4 result;
6921
6922   arg1 = (Dali::Vector4 *)jarg1;
6923   arg2 = (Dali::Vector4 *)jarg2;
6924   if (!arg2) {
6925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6926     return 0;
6927   }
6928   {
6929     try {
6930       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6931     } catch (std::out_of_range& e) {
6932       {
6933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6934       };
6935     } catch (std::exception& e) {
6936       {
6937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6938       };
6939     } catch (...) {
6940       {
6941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6942       };
6943     }
6944   }
6945   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6946   return jresult;
6947 }
6948
6949
6950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6951   void * jresult ;
6952   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6953   float arg2 ;
6954   Dali::Vector4 result;
6955
6956   arg1 = (Dali::Vector4 *)jarg1;
6957   arg2 = (float)jarg2;
6958   {
6959     try {
6960       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6961     } catch (std::out_of_range& e) {
6962       {
6963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6964       };
6965     } catch (std::exception& e) {
6966       {
6967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6968       };
6969     } catch (...) {
6970       {
6971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6972       };
6973     }
6974   }
6975   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6976   return jresult;
6977 }
6978
6979
6980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6981   void * jresult ;
6982   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6983   Dali::Vector4 *arg2 = 0 ;
6984   Dali::Vector4 *result = 0 ;
6985
6986   arg1 = (Dali::Vector4 *)jarg1;
6987   arg2 = (Dali::Vector4 *)jarg2;
6988   if (!arg2) {
6989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6990     return 0;
6991   }
6992   {
6993     try {
6994       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6995     } catch (std::out_of_range& e) {
6996       {
6997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6998       };
6999     } catch (std::exception& e) {
7000       {
7001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7002       };
7003     } catch (...) {
7004       {
7005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7006       };
7007     }
7008   }
7009   jresult = (void *)result;
7010   return jresult;
7011 }
7012
7013
7014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7015   void * jresult ;
7016   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7017   float arg2 ;
7018   Dali::Vector4 *result = 0 ;
7019
7020   arg1 = (Dali::Vector4 *)jarg1;
7021   arg2 = (float)jarg2;
7022   {
7023     try {
7024       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7025     } catch (std::out_of_range& e) {
7026       {
7027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7028       };
7029     } catch (std::exception& e) {
7030       {
7031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7032       };
7033     } catch (...) {
7034       {
7035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7036       };
7037     }
7038   }
7039   jresult = (void *)result;
7040   return jresult;
7041 }
7042
7043
7044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7045   void * jresult ;
7046   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7047   Dali::Vector4 *arg2 = 0 ;
7048   Dali::Vector4 result;
7049
7050   arg1 = (Dali::Vector4 *)jarg1;
7051   arg2 = (Dali::Vector4 *)jarg2;
7052   if (!arg2) {
7053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7054     return 0;
7055   }
7056   {
7057     try {
7058       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7059     } catch (std::out_of_range& e) {
7060       {
7061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7062       };
7063     } catch (std::exception& e) {
7064       {
7065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7066       };
7067     } catch (...) {
7068       {
7069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7070       };
7071     }
7072   }
7073   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7074   return jresult;
7075 }
7076
7077
7078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7079   void * jresult ;
7080   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7081   float arg2 ;
7082   Dali::Vector4 result;
7083
7084   arg1 = (Dali::Vector4 *)jarg1;
7085   arg2 = (float)jarg2;
7086   {
7087     try {
7088       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7089     } catch (std::out_of_range& e) {
7090       {
7091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7092       };
7093     } catch (std::exception& e) {
7094       {
7095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7096       };
7097     } catch (...) {
7098       {
7099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7100       };
7101     }
7102   }
7103   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7104   return jresult;
7105 }
7106
7107
7108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7109   void * jresult ;
7110   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7111   Dali::Vector4 *arg2 = 0 ;
7112   Dali::Vector4 *result = 0 ;
7113
7114   arg1 = (Dali::Vector4 *)jarg1;
7115   arg2 = (Dali::Vector4 *)jarg2;
7116   if (!arg2) {
7117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7118     return 0;
7119   }
7120   {
7121     try {
7122       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7123     } catch (std::out_of_range& e) {
7124       {
7125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7126       };
7127     } catch (std::exception& e) {
7128       {
7129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7130       };
7131     } catch (...) {
7132       {
7133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7134       };
7135     }
7136   }
7137   jresult = (void *)result;
7138   return jresult;
7139 }
7140
7141
7142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7143   void * jresult ;
7144   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7145   float arg2 ;
7146   Dali::Vector4 *result = 0 ;
7147
7148   arg1 = (Dali::Vector4 *)jarg1;
7149   arg2 = (float)jarg2;
7150   {
7151     try {
7152       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7153     } catch (std::out_of_range& e) {
7154       {
7155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7156       };
7157     } catch (std::exception& e) {
7158       {
7159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (...) {
7162       {
7163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7164       };
7165     }
7166   }
7167   jresult = (void *)result;
7168   return jresult;
7169 }
7170
7171
7172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7173   void * jresult ;
7174   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7175   Dali::Vector4 result;
7176
7177   arg1 = (Dali::Vector4 *)jarg1;
7178   {
7179     try {
7180       result = ((Dali::Vector4 const *)arg1)->operator -();
7181     } catch (std::out_of_range& e) {
7182       {
7183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7184       };
7185     } catch (std::exception& e) {
7186       {
7187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7188       };
7189     } catch (...) {
7190       {
7191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7192       };
7193     }
7194   }
7195   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7196   return jresult;
7197 }
7198
7199
7200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7201   unsigned int jresult ;
7202   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7203   Dali::Vector4 *arg2 = 0 ;
7204   bool result;
7205
7206   arg1 = (Dali::Vector4 *)jarg1;
7207   arg2 = (Dali::Vector4 *)jarg2;
7208   if (!arg2) {
7209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7210     return 0;
7211   }
7212   {
7213     try {
7214       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7215     } catch (std::out_of_range& e) {
7216       {
7217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7218       };
7219     } catch (std::exception& e) {
7220       {
7221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7222       };
7223     } catch (...) {
7224       {
7225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7226       };
7227     }
7228   }
7229   jresult = result;
7230   return jresult;
7231 }
7232
7233
7234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7235   unsigned int jresult ;
7236   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7237   Dali::Vector4 *arg2 = 0 ;
7238   bool result;
7239
7240   arg1 = (Dali::Vector4 *)jarg1;
7241   arg2 = (Dali::Vector4 *)jarg2;
7242   if (!arg2) {
7243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7244     return 0;
7245   }
7246   {
7247     try {
7248       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7249     } catch (std::out_of_range& e) {
7250       {
7251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7252       };
7253     } catch (std::exception& e) {
7254       {
7255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7256       };
7257     } catch (...) {
7258       {
7259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7260       };
7261     }
7262   }
7263   jresult = result;
7264   return jresult;
7265 }
7266
7267
7268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7269   float jresult ;
7270   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7271   unsigned int arg2 ;
7272   float *result = 0 ;
7273
7274   arg1 = (Dali::Vector4 *)jarg1;
7275   arg2 = (unsigned int)jarg2;
7276   {
7277     try {
7278       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7279     } catch (std::out_of_range& e) {
7280       {
7281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7282       };
7283     } catch (std::exception& e) {
7284       {
7285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7286       };
7287     } catch (...) {
7288       {
7289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7290       };
7291     }
7292   }
7293   jresult = *result;
7294   return jresult;
7295 }
7296
7297
7298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7299   float jresult ;
7300   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7301   Dali::Vector3 *arg2 = 0 ;
7302   float result;
7303
7304   arg1 = (Dali::Vector4 *)jarg1;
7305   arg2 = (Dali::Vector3 *)jarg2;
7306   if (!arg2) {
7307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7308     return 0;
7309   }
7310   {
7311     try {
7312       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7313     } catch (std::out_of_range& e) {
7314       {
7315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7316       };
7317     } catch (std::exception& e) {
7318       {
7319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7320       };
7321     } catch (...) {
7322       {
7323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7324       };
7325     }
7326   }
7327   jresult = result;
7328   return jresult;
7329 }
7330
7331
7332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7333   float jresult ;
7334   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7335   Dali::Vector4 *arg2 = 0 ;
7336   float result;
7337
7338   arg1 = (Dali::Vector4 *)jarg1;
7339   arg2 = (Dali::Vector4 *)jarg2;
7340   if (!arg2) {
7341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7342     return 0;
7343   }
7344   {
7345     try {
7346       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7347     } catch (std::out_of_range& e) {
7348       {
7349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7350       };
7351     } catch (std::exception& e) {
7352       {
7353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7354       };
7355     } catch (...) {
7356       {
7357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7358       };
7359     }
7360   }
7361   jresult = result;
7362   return jresult;
7363 }
7364
7365
7366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7367   float jresult ;
7368   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7369   Dali::Vector4 *arg2 = 0 ;
7370   float result;
7371
7372   arg1 = (Dali::Vector4 *)jarg1;
7373   arg2 = (Dali::Vector4 *)jarg2;
7374   if (!arg2) {
7375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7376     return 0;
7377   }
7378   {
7379     try {
7380       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7381     } catch (std::out_of_range& e) {
7382       {
7383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7384       };
7385     } catch (std::exception& e) {
7386       {
7387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7388       };
7389     } catch (...) {
7390       {
7391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7392       };
7393     }
7394   }
7395   jresult = result;
7396   return jresult;
7397 }
7398
7399
7400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7401   void * jresult ;
7402   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7403   Dali::Vector4 *arg2 = 0 ;
7404   Dali::Vector4 result;
7405
7406   arg1 = (Dali::Vector4 *)jarg1;
7407   arg2 = (Dali::Vector4 *)jarg2;
7408   if (!arg2) {
7409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7410     return 0;
7411   }
7412   {
7413     try {
7414       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7415     } catch (std::out_of_range& e) {
7416       {
7417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7418       };
7419     } catch (std::exception& e) {
7420       {
7421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7422       };
7423     } catch (...) {
7424       {
7425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7426       };
7427     }
7428   }
7429   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7430   return jresult;
7431 }
7432
7433
7434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7435   float jresult ;
7436   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7437   float result;
7438
7439   arg1 = (Dali::Vector4 *)jarg1;
7440   {
7441     try {
7442       result = (float)((Dali::Vector4 const *)arg1)->Length();
7443     } catch (std::out_of_range& e) {
7444       {
7445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7446       };
7447     } catch (std::exception& e) {
7448       {
7449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7450       };
7451     } catch (...) {
7452       {
7453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7454       };
7455     }
7456   }
7457   jresult = result;
7458   return jresult;
7459 }
7460
7461
7462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7463   float jresult ;
7464   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7465   float result;
7466
7467   arg1 = (Dali::Vector4 *)jarg1;
7468   {
7469     try {
7470       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7471     } catch (std::out_of_range& e) {
7472       {
7473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7474       };
7475     } catch (std::exception& e) {
7476       {
7477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7478       };
7479     } catch (...) {
7480       {
7481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7482       };
7483     }
7484   }
7485   jresult = result;
7486   return jresult;
7487 }
7488
7489
7490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7491   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7492
7493   arg1 = (Dali::Vector4 *)jarg1;
7494   {
7495     try {
7496       (arg1)->Normalize();
7497     } catch (std::out_of_range& e) {
7498       {
7499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7500       };
7501     } catch (std::exception& e) {
7502       {
7503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7504       };
7505     } catch (...) {
7506       {
7507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7508       };
7509     }
7510   }
7511 }
7512
7513
7514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7515   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7516   Dali::Vector4 *arg2 = 0 ;
7517   Dali::Vector4 *arg3 = 0 ;
7518
7519   arg1 = (Dali::Vector4 *)jarg1;
7520   arg2 = (Dali::Vector4 *)jarg2;
7521   if (!arg2) {
7522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7523     return ;
7524   }
7525   arg3 = (Dali::Vector4 *)jarg3;
7526   if (!arg3) {
7527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7528     return ;
7529   }
7530   {
7531     try {
7532       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7533     } catch (std::out_of_range& e) {
7534       {
7535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7536       };
7537     } catch (std::exception& e) {
7538       {
7539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7540       };
7541     } catch (...) {
7542       {
7543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7544       };
7545     }
7546   }
7547 }
7548
7549
7550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7551   void * jresult ;
7552   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7553   float *result = 0 ;
7554
7555   arg1 = (Dali::Vector4 *)jarg1;
7556   {
7557     try {
7558       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7559     } catch (std::out_of_range& e) {
7560       {
7561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7562       };
7563     } catch (std::exception& e) {
7564       {
7565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7566       };
7567     } catch (...) {
7568       {
7569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7570       };
7571     }
7572   }
7573   jresult = (void *)result;
7574   return jresult;
7575 }
7576
7577
7578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7580   float arg2 ;
7581
7582   arg1 = (Dali::Vector4 *)jarg1;
7583   arg2 = (float)jarg2;
7584   if (arg1) (arg1)->x = arg2;
7585 }
7586
7587
7588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7589   float jresult ;
7590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7591   float result;
7592
7593   arg1 = (Dali::Vector4 *)jarg1;
7594   result = (float) ((arg1)->x);
7595   jresult = result;
7596   return jresult;
7597 }
7598
7599
7600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7602   float arg2 ;
7603
7604   arg1 = (Dali::Vector4 *)jarg1;
7605   arg2 = (float)jarg2;
7606   if (arg1) (arg1)->r = arg2;
7607 }
7608
7609
7610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7611   float jresult ;
7612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7613   float result;
7614
7615   arg1 = (Dali::Vector4 *)jarg1;
7616   result = (float) ((arg1)->r);
7617   jresult = result;
7618   return jresult;
7619 }
7620
7621
7622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7623   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7624   float arg2 ;
7625
7626   arg1 = (Dali::Vector4 *)jarg1;
7627   arg2 = (float)jarg2;
7628   if (arg1) (arg1)->s = arg2;
7629 }
7630
7631
7632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7633   float jresult ;
7634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7635   float result;
7636
7637   arg1 = (Dali::Vector4 *)jarg1;
7638   result = (float) ((arg1)->s);
7639   jresult = result;
7640   return jresult;
7641 }
7642
7643
7644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7646   float arg2 ;
7647
7648   arg1 = (Dali::Vector4 *)jarg1;
7649   arg2 = (float)jarg2;
7650   if (arg1) (arg1)->y = arg2;
7651 }
7652
7653
7654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7655   float jresult ;
7656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7657   float result;
7658
7659   arg1 = (Dali::Vector4 *)jarg1;
7660   result = (float) ((arg1)->y);
7661   jresult = result;
7662   return jresult;
7663 }
7664
7665
7666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7668   float arg2 ;
7669
7670   arg1 = (Dali::Vector4 *)jarg1;
7671   arg2 = (float)jarg2;
7672   if (arg1) (arg1)->g = arg2;
7673 }
7674
7675
7676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7677   float jresult ;
7678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7679   float result;
7680
7681   arg1 = (Dali::Vector4 *)jarg1;
7682   result = (float) ((arg1)->g);
7683   jresult = result;
7684   return jresult;
7685 }
7686
7687
7688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7690   float arg2 ;
7691
7692   arg1 = (Dali::Vector4 *)jarg1;
7693   arg2 = (float)jarg2;
7694   if (arg1) (arg1)->t = arg2;
7695 }
7696
7697
7698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7699   float jresult ;
7700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7701   float result;
7702
7703   arg1 = (Dali::Vector4 *)jarg1;
7704   result = (float) ((arg1)->t);
7705   jresult = result;
7706   return jresult;
7707 }
7708
7709
7710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7712   float arg2 ;
7713
7714   arg1 = (Dali::Vector4 *)jarg1;
7715   arg2 = (float)jarg2;
7716   if (arg1) (arg1)->z = arg2;
7717 }
7718
7719
7720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7721   float jresult ;
7722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7723   float result;
7724
7725   arg1 = (Dali::Vector4 *)jarg1;
7726   result = (float) ((arg1)->z);
7727   jresult = result;
7728   return jresult;
7729 }
7730
7731
7732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7734   float arg2 ;
7735
7736   arg1 = (Dali::Vector4 *)jarg1;
7737   arg2 = (float)jarg2;
7738   if (arg1) (arg1)->b = arg2;
7739 }
7740
7741
7742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7743   float jresult ;
7744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7745   float result;
7746
7747   arg1 = (Dali::Vector4 *)jarg1;
7748   result = (float) ((arg1)->b);
7749   jresult = result;
7750   return jresult;
7751 }
7752
7753
7754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7756   float arg2 ;
7757
7758   arg1 = (Dali::Vector4 *)jarg1;
7759   arg2 = (float)jarg2;
7760   if (arg1) (arg1)->p = arg2;
7761 }
7762
7763
7764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7765   float jresult ;
7766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7767   float result;
7768
7769   arg1 = (Dali::Vector4 *)jarg1;
7770   result = (float) ((arg1)->p);
7771   jresult = result;
7772   return jresult;
7773 }
7774
7775
7776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7778   float arg2 ;
7779
7780   arg1 = (Dali::Vector4 *)jarg1;
7781   arg2 = (float)jarg2;
7782   if (arg1) (arg1)->w = arg2;
7783 }
7784
7785
7786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7787   float jresult ;
7788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7789   float result;
7790
7791   arg1 = (Dali::Vector4 *)jarg1;
7792   result = (float) ((arg1)->w);
7793   jresult = result;
7794   return jresult;
7795 }
7796
7797
7798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7799   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7800   float arg2 ;
7801
7802   arg1 = (Dali::Vector4 *)jarg1;
7803   arg2 = (float)jarg2;
7804   if (arg1) (arg1)->a = arg2;
7805 }
7806
7807
7808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7809   float jresult ;
7810   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7811   float result;
7812
7813   arg1 = (Dali::Vector4 *)jarg1;
7814   result = (float) ((arg1)->a);
7815   jresult = result;
7816   return jresult;
7817 }
7818
7819
7820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7821   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7822   float arg2 ;
7823
7824   arg1 = (Dali::Vector4 *)jarg1;
7825   arg2 = (float)jarg2;
7826   if (arg1) (arg1)->q = arg2;
7827 }
7828
7829
7830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7831   float jresult ;
7832   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7833   float result;
7834
7835   arg1 = (Dali::Vector4 *)jarg1;
7836   result = (float) ((arg1)->q);
7837   jresult = result;
7838   return jresult;
7839 }
7840
7841
7842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7843   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7844
7845   arg1 = (Dali::Vector4 *)jarg1;
7846   {
7847     try {
7848       delete arg1;
7849     } catch (std::out_of_range& e) {
7850       {
7851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7852       };
7853     } catch (std::exception& e) {
7854       {
7855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7856       };
7857     } catch (...) {
7858       {
7859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7860       };
7861     }
7862   }
7863 }
7864
7865
7866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7867   void * jresult ;
7868   Dali::Vector4 *arg1 = 0 ;
7869   Dali::Vector4 *arg2 = 0 ;
7870   Dali::Vector4 result;
7871
7872   arg1 = (Dali::Vector4 *)jarg1;
7873   if (!arg1) {
7874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7875     return 0;
7876   }
7877   arg2 = (Dali::Vector4 *)jarg2;
7878   if (!arg2) {
7879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7880     return 0;
7881   }
7882   {
7883     try {
7884       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7885     } catch (std::out_of_range& e) {
7886       {
7887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7888       };
7889     } catch (std::exception& e) {
7890       {
7891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7892       };
7893     } catch (...) {
7894       {
7895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7896       };
7897     }
7898   }
7899   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7900   return jresult;
7901 }
7902
7903
7904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7905   void * jresult ;
7906   Dali::Vector4 *arg1 = 0 ;
7907   Dali::Vector4 *arg2 = 0 ;
7908   Dali::Vector4 result;
7909
7910   arg1 = (Dali::Vector4 *)jarg1;
7911   if (!arg1) {
7912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7913     return 0;
7914   }
7915   arg2 = (Dali::Vector4 *)jarg2;
7916   if (!arg2) {
7917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7918     return 0;
7919   }
7920   {
7921     try {
7922       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7923     } catch (std::out_of_range& e) {
7924       {
7925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7926       };
7927     } catch (std::exception& e) {
7928       {
7929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7930       };
7931     } catch (...) {
7932       {
7933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7934       };
7935     }
7936   }
7937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7938   return jresult;
7939 }
7940
7941
7942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7943   void * jresult ;
7944   Dali::Vector4 *arg1 = 0 ;
7945   float *arg2 = 0 ;
7946   float *arg3 = 0 ;
7947   float temp2 ;
7948   float temp3 ;
7949   Dali::Vector4 result;
7950
7951   arg1 = (Dali::Vector4 *)jarg1;
7952   if (!arg1) {
7953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7954     return 0;
7955   }
7956   temp2 = (float)jarg2;
7957   arg2 = &temp2;
7958   temp3 = (float)jarg3;
7959   arg3 = &temp3;
7960   {
7961     try {
7962       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7963     } catch (std::out_of_range& e) {
7964       {
7965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7966       };
7967     } catch (std::exception& e) {
7968       {
7969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (...) {
7972       {
7973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7974       };
7975     }
7976   }
7977   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7978   return jresult;
7979 }
7980
7981
7982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
7983   void * jresult ;
7984   Dali::Uint16Pair *result = 0 ;
7985
7986   {
7987     try {
7988       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7989     } catch (std::out_of_range& e) {
7990       {
7991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7992       };
7993     } catch (std::exception& e) {
7994       {
7995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7996       };
7997     } catch (...) {
7998       {
7999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8000       };
8001     }
8002   }
8003   jresult = (void *)result;
8004   return jresult;
8005 }
8006
8007
8008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8009   void * jresult ;
8010   uint32_t arg1 ;
8011   uint32_t arg2 ;
8012   Dali::Uint16Pair *result = 0 ;
8013
8014   arg1 = (uint32_t)jarg1;
8015   arg2 = (uint32_t)jarg2;
8016   {
8017     try {
8018       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8019     } catch (std::out_of_range& e) {
8020       {
8021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8022       };
8023     } catch (std::exception& e) {
8024       {
8025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8026       };
8027     } catch (...) {
8028       {
8029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8030       };
8031     }
8032   }
8033   jresult = (void *)result;
8034   return jresult;
8035 }
8036
8037
8038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8039   void * jresult ;
8040   Dali::Uint16Pair *arg1 = 0 ;
8041   Dali::Uint16Pair *result = 0 ;
8042
8043   arg1 = (Dali::Uint16Pair *)jarg1;
8044   if (!arg1) {
8045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8046     return 0;
8047   }
8048   {
8049     try {
8050       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8051     } catch (std::out_of_range& e) {
8052       {
8053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8054       };
8055     } catch (std::exception& e) {
8056       {
8057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8058       };
8059     } catch (...) {
8060       {
8061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8062       };
8063     }
8064   }
8065   jresult = (void *)result;
8066   return jresult;
8067 }
8068
8069
8070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8071   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8072   uint16_t arg2 ;
8073
8074   arg1 = (Dali::Uint16Pair *)jarg1;
8075   arg2 = (uint16_t)jarg2;
8076   {
8077     try {
8078       (arg1)->SetWidth(arg2);
8079     } catch (std::out_of_range& e) {
8080       {
8081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8082       };
8083     } catch (std::exception& e) {
8084       {
8085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8086       };
8087     } catch (...) {
8088       {
8089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8090       };
8091     }
8092   }
8093 }
8094
8095
8096 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8097   unsigned short jresult ;
8098   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8099   uint16_t result;
8100
8101   arg1 = (Dali::Uint16Pair *)jarg1;
8102   {
8103     try {
8104       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8105     } catch (std::out_of_range& e) {
8106       {
8107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8108       };
8109     } catch (std::exception& e) {
8110       {
8111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8112       };
8113     } catch (...) {
8114       {
8115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8116       };
8117     }
8118   }
8119   jresult = result;
8120   return jresult;
8121 }
8122
8123
8124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8125   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8126   uint16_t arg2 ;
8127
8128   arg1 = (Dali::Uint16Pair *)jarg1;
8129   arg2 = (uint16_t)jarg2;
8130   {
8131     try {
8132       (arg1)->SetHeight(arg2);
8133     } catch (std::out_of_range& e) {
8134       {
8135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8136       };
8137     } catch (std::exception& e) {
8138       {
8139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8140       };
8141     } catch (...) {
8142       {
8143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8144       };
8145     }
8146   }
8147 }
8148
8149
8150 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8151   unsigned short jresult ;
8152   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8153   uint16_t result;
8154
8155   arg1 = (Dali::Uint16Pair *)jarg1;
8156   {
8157     try {
8158       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8159     } catch (std::out_of_range& e) {
8160       {
8161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8162       };
8163     } catch (std::exception& e) {
8164       {
8165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8166       };
8167     } catch (...) {
8168       {
8169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8170       };
8171     }
8172   }
8173   jresult = result;
8174   return jresult;
8175 }
8176
8177
8178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8179   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8180   uint16_t arg2 ;
8181
8182   arg1 = (Dali::Uint16Pair *)jarg1;
8183   arg2 = (uint16_t)jarg2;
8184   {
8185     try {
8186       (arg1)->SetX(arg2);
8187     } catch (std::out_of_range& e) {
8188       {
8189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8190       };
8191     } catch (std::exception& e) {
8192       {
8193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8194       };
8195     } catch (...) {
8196       {
8197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8198       };
8199     }
8200   }
8201 }
8202
8203
8204 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8205   unsigned short jresult ;
8206   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8207   uint16_t result;
8208
8209   arg1 = (Dali::Uint16Pair *)jarg1;
8210   {
8211     try {
8212       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8213     } catch (std::out_of_range& e) {
8214       {
8215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8216       };
8217     } catch (std::exception& e) {
8218       {
8219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8220       };
8221     } catch (...) {
8222       {
8223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8224       };
8225     }
8226   }
8227   jresult = result;
8228   return jresult;
8229 }
8230
8231
8232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8233   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8234   uint16_t arg2 ;
8235
8236   arg1 = (Dali::Uint16Pair *)jarg1;
8237   arg2 = (uint16_t)jarg2;
8238   {
8239     try {
8240       (arg1)->SetY(arg2);
8241     } catch (std::out_of_range& e) {
8242       {
8243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8244       };
8245     } catch (std::exception& e) {
8246       {
8247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8248       };
8249     } catch (...) {
8250       {
8251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8252       };
8253     }
8254   }
8255 }
8256
8257
8258 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8259   unsigned short jresult ;
8260   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8261   uint16_t result;
8262
8263   arg1 = (Dali::Uint16Pair *)jarg1;
8264   {
8265     try {
8266       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8267     } catch (std::out_of_range& e) {
8268       {
8269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8270       };
8271     } catch (std::exception& e) {
8272       {
8273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8274       };
8275     } catch (...) {
8276       {
8277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8278       };
8279     }
8280   }
8281   jresult = result;
8282   return jresult;
8283 }
8284
8285
8286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8287   void * jresult ;
8288   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8289   Dali::Uint16Pair *arg2 = 0 ;
8290   Dali::Uint16Pair *result = 0 ;
8291
8292   arg1 = (Dali::Uint16Pair *)jarg1;
8293   arg2 = (Dali::Uint16Pair *)jarg2;
8294   if (!arg2) {
8295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8296     return 0;
8297   }
8298   {
8299     try {
8300       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8301     } catch (std::out_of_range& e) {
8302       {
8303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8304       };
8305     } catch (std::exception& e) {
8306       {
8307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8308       };
8309     } catch (...) {
8310       {
8311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8312       };
8313     }
8314   }
8315   jresult = (void *)result;
8316   return jresult;
8317 }
8318
8319
8320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8321   unsigned int jresult ;
8322   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8323   Dali::Uint16Pair *arg2 = 0 ;
8324   bool result;
8325
8326   arg1 = (Dali::Uint16Pair *)jarg1;
8327   arg2 = (Dali::Uint16Pair *)jarg2;
8328   if (!arg2) {
8329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8330     return 0;
8331   }
8332   {
8333     try {
8334       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8335     } catch (std::out_of_range& e) {
8336       {
8337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8338       };
8339     } catch (std::exception& e) {
8340       {
8341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8342       };
8343     } catch (...) {
8344       {
8345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8346       };
8347     }
8348   }
8349   jresult = result;
8350   return jresult;
8351 }
8352
8353
8354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8355   unsigned int jresult ;
8356   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8357   Dali::Uint16Pair *arg2 = 0 ;
8358   bool result;
8359
8360   arg1 = (Dali::Uint16Pair *)jarg1;
8361   arg2 = (Dali::Uint16Pair *)jarg2;
8362   if (!arg2) {
8363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8364     return 0;
8365   }
8366   {
8367     try {
8368       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8369     } catch (std::out_of_range& e) {
8370       {
8371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8372       };
8373     } catch (std::exception& e) {
8374       {
8375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8376       };
8377     } catch (...) {
8378       {
8379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8380       };
8381     }
8382   }
8383   jresult = result;
8384   return jresult;
8385 }
8386
8387
8388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8389   unsigned int jresult ;
8390   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8391   Dali::Uint16Pair *arg2 = 0 ;
8392   bool result;
8393
8394   arg1 = (Dali::Uint16Pair *)jarg1;
8395   arg2 = (Dali::Uint16Pair *)jarg2;
8396   if (!arg2) {
8397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8398     return 0;
8399   }
8400   {
8401     try {
8402       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8403     } catch (std::out_of_range& e) {
8404       {
8405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8406       };
8407     } catch (std::exception& e) {
8408       {
8409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8410       };
8411     } catch (...) {
8412       {
8413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8414       };
8415     }
8416   }
8417   jresult = result;
8418   return jresult;
8419 }
8420
8421
8422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8423   unsigned int jresult ;
8424   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8425   Dali::Uint16Pair *arg2 = 0 ;
8426   bool result;
8427
8428   arg1 = (Dali::Uint16Pair *)jarg1;
8429   arg2 = (Dali::Uint16Pair *)jarg2;
8430   if (!arg2) {
8431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8432     return 0;
8433   }
8434   {
8435     try {
8436       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8437     } catch (std::out_of_range& e) {
8438       {
8439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8440       };
8441     } catch (std::exception& e) {
8442       {
8443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8444       };
8445     } catch (...) {
8446       {
8447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8448       };
8449     }
8450   }
8451   jresult = result;
8452   return jresult;
8453 }
8454
8455
8456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8457   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8458
8459   arg1 = (Dali::Uint16Pair *)jarg1;
8460   {
8461     try {
8462       delete arg1;
8463     } catch (std::out_of_range& e) {
8464       {
8465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8466       };
8467     } catch (std::exception& e) {
8468       {
8469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8470       };
8471     } catch (...) {
8472       {
8473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8474       };
8475     }
8476   }
8477 }
8478
8479
8480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8481   void * jresult ;
8482   Dali::Degree *result = 0 ;
8483
8484   {
8485     try {
8486       result = (Dali::Degree *)new Dali::Degree();
8487     } catch (std::out_of_range& e) {
8488       {
8489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8490       };
8491     } catch (std::exception& e) {
8492       {
8493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8494       };
8495     } catch (...) {
8496       {
8497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8498       };
8499     }
8500   }
8501   jresult = (void *)result;
8502   return jresult;
8503 }
8504
8505
8506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8507   void * jresult ;
8508   float arg1 ;
8509   Dali::Degree *result = 0 ;
8510
8511   arg1 = (float)jarg1;
8512   {
8513     try {
8514       result = (Dali::Degree *)new Dali::Degree(arg1);
8515     } catch (std::out_of_range& e) {
8516       {
8517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8518       };
8519     } catch (std::exception& e) {
8520       {
8521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8522       };
8523     } catch (...) {
8524       {
8525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8526       };
8527     }
8528   }
8529   jresult = (void *)result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8535   void * jresult ;
8536   Dali::Radian arg1 ;
8537   Dali::Radian *argp1 ;
8538   Dali::Degree *result = 0 ;
8539
8540   argp1 = (Dali::Radian *)jarg1;
8541   if (!argp1) {
8542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8543     return 0;
8544   }
8545   arg1 = *argp1;
8546   {
8547     try {
8548       result = (Dali::Degree *)new Dali::Degree(arg1);
8549     } catch (std::out_of_range& e) {
8550       {
8551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8552       };
8553     } catch (std::exception& e) {
8554       {
8555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8556       };
8557     } catch (...) {
8558       {
8559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8560       };
8561     }
8562   }
8563   jresult = (void *)result;
8564   return jresult;
8565 }
8566
8567
8568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8569   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8570   float arg2 ;
8571
8572   arg1 = (Dali::Degree *)jarg1;
8573   arg2 = (float)jarg2;
8574   if (arg1) (arg1)->degree = arg2;
8575 }
8576
8577
8578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8579   float jresult ;
8580   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8581   float result;
8582
8583   arg1 = (Dali::Degree *)jarg1;
8584   result = (float) ((arg1)->degree);
8585   jresult = result;
8586   return jresult;
8587 }
8588
8589
8590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8591   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8592
8593   arg1 = (Dali::Degree *)jarg1;
8594   {
8595     try {
8596       delete arg1;
8597     } catch (std::out_of_range& e) {
8598       {
8599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8600       };
8601     } catch (std::exception& e) {
8602       {
8603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8604       };
8605     } catch (...) {
8606       {
8607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8608       };
8609     }
8610   }
8611 }
8612
8613
8614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8615   void * jresult ;
8616   Dali::Radian *result = 0 ;
8617
8618   result = (Dali::Radian *)&Dali::ANGLE_360;
8619   jresult = (void *)result;
8620   return jresult;
8621 }
8622
8623
8624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8625   void * jresult ;
8626   Dali::Radian *result = 0 ;
8627
8628   result = (Dali::Radian *)&Dali::ANGLE_315;
8629   jresult = (void *)result;
8630   return jresult;
8631 }
8632
8633
8634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8635   void * jresult ;
8636   Dali::Radian *result = 0 ;
8637
8638   result = (Dali::Radian *)&Dali::ANGLE_270;
8639   jresult = (void *)result;
8640   return jresult;
8641 }
8642
8643
8644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8645   void * jresult ;
8646   Dali::Radian *result = 0 ;
8647
8648   result = (Dali::Radian *)&Dali::ANGLE_225;
8649   jresult = (void *)result;
8650   return jresult;
8651 }
8652
8653
8654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8655   void * jresult ;
8656   Dali::Radian *result = 0 ;
8657
8658   result = (Dali::Radian *)&Dali::ANGLE_180;
8659   jresult = (void *)result;
8660   return jresult;
8661 }
8662
8663
8664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8665   void * jresult ;
8666   Dali::Radian *result = 0 ;
8667
8668   result = (Dali::Radian *)&Dali::ANGLE_135;
8669   jresult = (void *)result;
8670   return jresult;
8671 }
8672
8673
8674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8675   void * jresult ;
8676   Dali::Radian *result = 0 ;
8677
8678   result = (Dali::Radian *)&Dali::ANGLE_120;
8679   jresult = (void *)result;
8680   return jresult;
8681 }
8682
8683
8684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8685   void * jresult ;
8686   Dali::Radian *result = 0 ;
8687
8688   result = (Dali::Radian *)&Dali::ANGLE_90;
8689   jresult = (void *)result;
8690   return jresult;
8691 }
8692
8693
8694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8695   void * jresult ;
8696   Dali::Radian *result = 0 ;
8697
8698   result = (Dali::Radian *)&Dali::ANGLE_60;
8699   jresult = (void *)result;
8700   return jresult;
8701 }
8702
8703
8704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8705   void * jresult ;
8706   Dali::Radian *result = 0 ;
8707
8708   result = (Dali::Radian *)&Dali::ANGLE_45;
8709   jresult = (void *)result;
8710   return jresult;
8711 }
8712
8713
8714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8715   void * jresult ;
8716   Dali::Radian *result = 0 ;
8717
8718   result = (Dali::Radian *)&Dali::ANGLE_30;
8719   jresult = (void *)result;
8720   return jresult;
8721 }
8722
8723
8724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8725   void * jresult ;
8726   Dali::Radian *result = 0 ;
8727
8728   result = (Dali::Radian *)&Dali::ANGLE_0;
8729   jresult = (void *)result;
8730   return jresult;
8731 }
8732
8733
8734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8735   unsigned int jresult ;
8736   Dali::Degree *arg1 = 0 ;
8737   Dali::Degree *arg2 = 0 ;
8738   bool result;
8739
8740   arg1 = (Dali::Degree *)jarg1;
8741   if (!arg1) {
8742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8743     return 0;
8744   }
8745   arg2 = (Dali::Degree *)jarg2;
8746   if (!arg2) {
8747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8748     return 0;
8749   }
8750   {
8751     try {
8752       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8753     } catch (std::out_of_range& e) {
8754       {
8755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8756       };
8757     } catch (std::exception& e) {
8758       {
8759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8760       };
8761     } catch (...) {
8762       {
8763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8764       };
8765     }
8766   }
8767   jresult = result;
8768   return jresult;
8769 }
8770
8771
8772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8773   unsigned int jresult ;
8774   Dali::Degree *arg1 = 0 ;
8775   Dali::Degree *arg2 = 0 ;
8776   bool result;
8777
8778   arg1 = (Dali::Degree *)jarg1;
8779   if (!arg1) {
8780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8781     return 0;
8782   }
8783   arg2 = (Dali::Degree *)jarg2;
8784   if (!arg2) {
8785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8786     return 0;
8787   }
8788   {
8789     try {
8790       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8791     } catch (std::out_of_range& e) {
8792       {
8793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8794       };
8795     } catch (std::exception& e) {
8796       {
8797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8798       };
8799     } catch (...) {
8800       {
8801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8802       };
8803     }
8804   }
8805   jresult = result;
8806   return jresult;
8807 }
8808
8809
8810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8811   void * jresult ;
8812   Dali::Degree arg1 ;
8813   float arg2 ;
8814   float arg3 ;
8815   Dali::Degree *argp1 ;
8816   Dali::Degree result;
8817
8818   argp1 = (Dali::Degree *)jarg1;
8819   if (!argp1) {
8820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8821     return 0;
8822   }
8823   arg1 = *argp1;
8824   arg2 = (float)jarg2;
8825   arg3 = (float)jarg3;
8826   {
8827     try {
8828       result = Dali::Clamp(arg1,arg2,arg3);
8829     } catch (std::out_of_range& e) {
8830       {
8831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8832       };
8833     } catch (std::exception& e) {
8834       {
8835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8836       };
8837     } catch (...) {
8838       {
8839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8840       };
8841     }
8842   }
8843   jresult = new Dali::Degree((const Dali::Degree &)result);
8844   return jresult;
8845 }
8846
8847
8848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8849   void * jresult ;
8850   Dali::Radian *result = 0 ;
8851
8852   {
8853     try {
8854       result = (Dali::Radian *)new Dali::Radian();
8855     } catch (std::out_of_range& e) {
8856       {
8857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8858       };
8859     } catch (std::exception& e) {
8860       {
8861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8862       };
8863     } catch (...) {
8864       {
8865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8866       };
8867     }
8868   }
8869   jresult = (void *)result;
8870   return jresult;
8871 }
8872
8873
8874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8875   void * jresult ;
8876   float arg1 ;
8877   Dali::Radian *result = 0 ;
8878
8879   arg1 = (float)jarg1;
8880   {
8881     try {
8882       result = (Dali::Radian *)new Dali::Radian(arg1);
8883     } catch (std::out_of_range& e) {
8884       {
8885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8886       };
8887     } catch (std::exception& e) {
8888       {
8889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8890       };
8891     } catch (...) {
8892       {
8893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8894       };
8895     }
8896   }
8897   jresult = (void *)result;
8898   return jresult;
8899 }
8900
8901
8902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8903   void * jresult ;
8904   Dali::Degree arg1 ;
8905   Dali::Degree *argp1 ;
8906   Dali::Radian *result = 0 ;
8907
8908   argp1 = (Dali::Degree *)jarg1;
8909   if (!argp1) {
8910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8911     return 0;
8912   }
8913   arg1 = *argp1;
8914   {
8915     try {
8916       result = (Dali::Radian *)new Dali::Radian(arg1);
8917     } catch (std::out_of_range& e) {
8918       {
8919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8920       };
8921     } catch (std::exception& e) {
8922       {
8923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8924       };
8925     } catch (...) {
8926       {
8927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8928       };
8929     }
8930   }
8931   jresult = (void *)result;
8932   return jresult;
8933 }
8934
8935
8936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8937   void * jresult ;
8938   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8939   float arg2 ;
8940   Dali::Radian *result = 0 ;
8941
8942   arg1 = (Dali::Radian *)jarg1;
8943   arg2 = (float)jarg2;
8944   {
8945     try {
8946       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8947     } catch (std::out_of_range& e) {
8948       {
8949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8950       };
8951     } catch (std::exception& e) {
8952       {
8953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8954       };
8955     } catch (...) {
8956       {
8957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8958       };
8959     }
8960   }
8961   jresult = (void *)result;
8962   return jresult;
8963 }
8964
8965
8966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8967   void * jresult ;
8968   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8969   Dali::Degree arg2 ;
8970   Dali::Degree *argp2 ;
8971   Dali::Radian *result = 0 ;
8972
8973   arg1 = (Dali::Radian *)jarg1;
8974   argp2 = (Dali::Degree *)jarg2;
8975   if (!argp2) {
8976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8977     return 0;
8978   }
8979   arg2 = *argp2;
8980   {
8981     try {
8982       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8983     } catch (std::out_of_range& e) {
8984       {
8985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8986       };
8987     } catch (std::exception& e) {
8988       {
8989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8990       };
8991     } catch (...) {
8992       {
8993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8994       };
8995     }
8996   }
8997   jresult = (void *)result;
8998   return jresult;
8999 }
9000
9001
9002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9003   float jresult ;
9004   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9005   float result;
9006
9007   arg1 = (Dali::Radian *)jarg1;
9008   {
9009     try {
9010       result = (float)((Dali::Radian const *)arg1)->operator float();
9011     } catch (std::out_of_range& e) {
9012       {
9013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9014       };
9015     } catch (std::exception& e) {
9016       {
9017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9018       };
9019     } catch (...) {
9020       {
9021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9022       };
9023     }
9024   }
9025   jresult = result;
9026   return jresult;
9027 }
9028
9029
9030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9031   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9032   float arg2 ;
9033
9034   arg1 = (Dali::Radian *)jarg1;
9035   arg2 = (float)jarg2;
9036   if (arg1) (arg1)->radian = arg2;
9037 }
9038
9039
9040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9041   float jresult ;
9042   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9043   float result;
9044
9045   arg1 = (Dali::Radian *)jarg1;
9046   result = (float) ((arg1)->radian);
9047   jresult = result;
9048   return jresult;
9049 }
9050
9051
9052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9053   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9054
9055   arg1 = (Dali::Radian *)jarg1;
9056   {
9057     try {
9058       delete arg1;
9059     } catch (std::out_of_range& e) {
9060       {
9061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9062       };
9063     } catch (std::exception& e) {
9064       {
9065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9066       };
9067     } catch (...) {
9068       {
9069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9070       };
9071     }
9072   }
9073 }
9074
9075
9076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9077   unsigned int jresult ;
9078   Dali::Radian arg1 ;
9079   Dali::Radian arg2 ;
9080   Dali::Radian *argp1 ;
9081   Dali::Radian *argp2 ;
9082   bool result;
9083
9084   argp1 = (Dali::Radian *)jarg1;
9085   if (!argp1) {
9086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9087     return 0;
9088   }
9089   arg1 = *argp1;
9090   argp2 = (Dali::Radian *)jarg2;
9091   if (!argp2) {
9092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9093     return 0;
9094   }
9095   arg2 = *argp2;
9096   {
9097     try {
9098       result = (bool)Dali::operator ==(arg1,arg2);
9099     } catch (std::out_of_range& e) {
9100       {
9101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9102       };
9103     } catch (std::exception& e) {
9104       {
9105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9106       };
9107     } catch (...) {
9108       {
9109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9110       };
9111     }
9112   }
9113   jresult = result;
9114   return jresult;
9115 }
9116
9117
9118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9119   unsigned int jresult ;
9120   Dali::Radian arg1 ;
9121   Dali::Radian arg2 ;
9122   Dali::Radian *argp1 ;
9123   Dali::Radian *argp2 ;
9124   bool result;
9125
9126   argp1 = (Dali::Radian *)jarg1;
9127   if (!argp1) {
9128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9129     return 0;
9130   }
9131   arg1 = *argp1;
9132   argp2 = (Dali::Radian *)jarg2;
9133   if (!argp2) {
9134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9135     return 0;
9136   }
9137   arg2 = *argp2;
9138   {
9139     try {
9140       result = (bool)Dali::operator !=(arg1,arg2);
9141     } catch (std::out_of_range& e) {
9142       {
9143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9144       };
9145     } catch (std::exception& e) {
9146       {
9147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9148       };
9149     } catch (...) {
9150       {
9151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9152       };
9153     }
9154   }
9155   jresult = result;
9156   return jresult;
9157 }
9158
9159
9160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9161   unsigned int jresult ;
9162   Dali::Radian arg1 ;
9163   Dali::Degree arg2 ;
9164   Dali::Radian *argp1 ;
9165   Dali::Degree *argp2 ;
9166   bool result;
9167
9168   argp1 = (Dali::Radian *)jarg1;
9169   if (!argp1) {
9170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9171     return 0;
9172   }
9173   arg1 = *argp1;
9174   argp2 = (Dali::Degree *)jarg2;
9175   if (!argp2) {
9176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9177     return 0;
9178   }
9179   arg2 = *argp2;
9180   {
9181     try {
9182       result = (bool)Dali::operator ==(arg1,arg2);
9183     } catch (std::out_of_range& e) {
9184       {
9185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9186       };
9187     } catch (std::exception& e) {
9188       {
9189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9190       };
9191     } catch (...) {
9192       {
9193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9194       };
9195     }
9196   }
9197   jresult = result;
9198   return jresult;
9199 }
9200
9201
9202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9203   unsigned int jresult ;
9204   Dali::Radian arg1 ;
9205   Dali::Degree arg2 ;
9206   Dali::Radian *argp1 ;
9207   Dali::Degree *argp2 ;
9208   bool result;
9209
9210   argp1 = (Dali::Radian *)jarg1;
9211   if (!argp1) {
9212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9213     return 0;
9214   }
9215   arg1 = *argp1;
9216   argp2 = (Dali::Degree *)jarg2;
9217   if (!argp2) {
9218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9219     return 0;
9220   }
9221   arg2 = *argp2;
9222   {
9223     try {
9224       result = (bool)Dali::operator !=(arg1,arg2);
9225     } catch (std::out_of_range& e) {
9226       {
9227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9228       };
9229     } catch (std::exception& e) {
9230       {
9231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9232       };
9233     } catch (...) {
9234       {
9235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9236       };
9237     }
9238   }
9239   jresult = result;
9240   return jresult;
9241 }
9242
9243
9244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9245   unsigned int jresult ;
9246   Dali::Degree arg1 ;
9247   Dali::Radian arg2 ;
9248   Dali::Degree *argp1 ;
9249   Dali::Radian *argp2 ;
9250   bool result;
9251
9252   argp1 = (Dali::Degree *)jarg1;
9253   if (!argp1) {
9254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9255     return 0;
9256   }
9257   arg1 = *argp1;
9258   argp2 = (Dali::Radian *)jarg2;
9259   if (!argp2) {
9260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9261     return 0;
9262   }
9263   arg2 = *argp2;
9264   {
9265     try {
9266       result = (bool)Dali::operator ==(arg1,arg2);
9267     } catch (std::out_of_range& e) {
9268       {
9269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9270       };
9271     } catch (std::exception& e) {
9272       {
9273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9274       };
9275     } catch (...) {
9276       {
9277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9278       };
9279     }
9280   }
9281   jresult = result;
9282   return jresult;
9283 }
9284
9285
9286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9287   unsigned int jresult ;
9288   Dali::Degree arg1 ;
9289   Dali::Radian arg2 ;
9290   Dali::Degree *argp1 ;
9291   Dali::Radian *argp2 ;
9292   bool result;
9293
9294   argp1 = (Dali::Degree *)jarg1;
9295   if (!argp1) {
9296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9297     return 0;
9298   }
9299   arg1 = *argp1;
9300   argp2 = (Dali::Radian *)jarg2;
9301   if (!argp2) {
9302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9303     return 0;
9304   }
9305   arg2 = *argp2;
9306   {
9307     try {
9308       result = (bool)Dali::operator !=(arg1,arg2);
9309     } catch (std::out_of_range& e) {
9310       {
9311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9312       };
9313     } catch (std::exception& e) {
9314       {
9315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9316       };
9317     } catch (...) {
9318       {
9319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9320       };
9321     }
9322   }
9323   jresult = result;
9324   return jresult;
9325 }
9326
9327
9328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9329   unsigned int jresult ;
9330   Dali::Radian arg1 ;
9331   Dali::Radian arg2 ;
9332   Dali::Radian *argp1 ;
9333   Dali::Radian *argp2 ;
9334   bool result;
9335
9336   argp1 = (Dali::Radian *)jarg1;
9337   if (!argp1) {
9338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9339     return 0;
9340   }
9341   arg1 = *argp1;
9342   argp2 = (Dali::Radian *)jarg2;
9343   if (!argp2) {
9344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9345     return 0;
9346   }
9347   arg2 = *argp2;
9348   {
9349     try {
9350       result = (bool)Dali::operator >(arg1,arg2);
9351     } catch (std::out_of_range& e) {
9352       {
9353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9354       };
9355     } catch (std::exception& e) {
9356       {
9357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9358       };
9359     } catch (...) {
9360       {
9361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9362       };
9363     }
9364   }
9365   jresult = result;
9366   return jresult;
9367 }
9368
9369
9370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9371   unsigned int jresult ;
9372   Dali::Radian arg1 ;
9373   Dali::Degree arg2 ;
9374   Dali::Radian *argp1 ;
9375   Dali::Degree *argp2 ;
9376   bool result;
9377
9378   argp1 = (Dali::Radian *)jarg1;
9379   if (!argp1) {
9380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9381     return 0;
9382   }
9383   arg1 = *argp1;
9384   argp2 = (Dali::Degree *)jarg2;
9385   if (!argp2) {
9386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9387     return 0;
9388   }
9389   arg2 = *argp2;
9390   {
9391     try {
9392       result = (bool)Dali::operator >(arg1,arg2);
9393     } catch (std::out_of_range& e) {
9394       {
9395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9396       };
9397     } catch (std::exception& e) {
9398       {
9399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9400       };
9401     } catch (...) {
9402       {
9403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9404       };
9405     }
9406   }
9407   jresult = result;
9408   return jresult;
9409 }
9410
9411
9412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9413   unsigned int jresult ;
9414   Dali::Degree arg1 ;
9415   Dali::Radian arg2 ;
9416   Dali::Degree *argp1 ;
9417   Dali::Radian *argp2 ;
9418   bool result;
9419
9420   argp1 = (Dali::Degree *)jarg1;
9421   if (!argp1) {
9422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9423     return 0;
9424   }
9425   arg1 = *argp1;
9426   argp2 = (Dali::Radian *)jarg2;
9427   if (!argp2) {
9428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9429     return 0;
9430   }
9431   arg2 = *argp2;
9432   {
9433     try {
9434       result = (bool)Dali::operator >(arg1,arg2);
9435     } catch (std::out_of_range& e) {
9436       {
9437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9438       };
9439     } catch (std::exception& e) {
9440       {
9441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9442       };
9443     } catch (...) {
9444       {
9445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9446       };
9447     }
9448   }
9449   jresult = result;
9450   return jresult;
9451 }
9452
9453
9454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9455   unsigned int jresult ;
9456   Dali::Radian arg1 ;
9457   Dali::Radian arg2 ;
9458   Dali::Radian *argp1 ;
9459   Dali::Radian *argp2 ;
9460   bool result;
9461
9462   argp1 = (Dali::Radian *)jarg1;
9463   if (!argp1) {
9464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9465     return 0;
9466   }
9467   arg1 = *argp1;
9468   argp2 = (Dali::Radian *)jarg2;
9469   if (!argp2) {
9470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9471     return 0;
9472   }
9473   arg2 = *argp2;
9474   {
9475     try {
9476       result = (bool)Dali::operator <(arg1,arg2);
9477     } catch (std::out_of_range& e) {
9478       {
9479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9480       };
9481     } catch (std::exception& e) {
9482       {
9483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9484       };
9485     } catch (...) {
9486       {
9487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9488       };
9489     }
9490   }
9491   jresult = result;
9492   return jresult;
9493 }
9494
9495
9496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9497   unsigned int jresult ;
9498   Dali::Radian arg1 ;
9499   Dali::Degree arg2 ;
9500   Dali::Radian *argp1 ;
9501   Dali::Degree *argp2 ;
9502   bool result;
9503
9504   argp1 = (Dali::Radian *)jarg1;
9505   if (!argp1) {
9506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9507     return 0;
9508   }
9509   arg1 = *argp1;
9510   argp2 = (Dali::Degree *)jarg2;
9511   if (!argp2) {
9512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9513     return 0;
9514   }
9515   arg2 = *argp2;
9516   {
9517     try {
9518       result = (bool)Dali::operator <(arg1,arg2);
9519     } catch (std::out_of_range& e) {
9520       {
9521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9522       };
9523     } catch (std::exception& e) {
9524       {
9525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9526       };
9527     } catch (...) {
9528       {
9529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9530       };
9531     }
9532   }
9533   jresult = result;
9534   return jresult;
9535 }
9536
9537
9538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9539   unsigned int jresult ;
9540   Dali::Degree arg1 ;
9541   Dali::Radian arg2 ;
9542   Dali::Degree *argp1 ;
9543   Dali::Radian *argp2 ;
9544   bool result;
9545
9546   argp1 = (Dali::Degree *)jarg1;
9547   if (!argp1) {
9548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9549     return 0;
9550   }
9551   arg1 = *argp1;
9552   argp2 = (Dali::Radian *)jarg2;
9553   if (!argp2) {
9554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9555     return 0;
9556   }
9557   arg2 = *argp2;
9558   {
9559     try {
9560       result = (bool)Dali::operator <(arg1,arg2);
9561     } catch (std::out_of_range& e) {
9562       {
9563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9564       };
9565     } catch (std::exception& e) {
9566       {
9567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9568       };
9569     } catch (...) {
9570       {
9571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9572       };
9573     }
9574   }
9575   jresult = result;
9576   return jresult;
9577 }
9578
9579
9580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9581   void * jresult ;
9582   Dali::Radian arg1 ;
9583   float arg2 ;
9584   Dali::Radian *argp1 ;
9585   Dali::Radian result;
9586
9587   argp1 = (Dali::Radian *)jarg1;
9588   if (!argp1) {
9589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9590     return 0;
9591   }
9592   arg1 = *argp1;
9593   arg2 = (float)jarg2;
9594   {
9595     try {
9596       result = Dali::operator *(arg1,arg2);
9597     } catch (std::out_of_range& e) {
9598       {
9599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9600       };
9601     } catch (std::exception& e) {
9602       {
9603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9604       };
9605     } catch (...) {
9606       {
9607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9608       };
9609     }
9610   }
9611   jresult = new Dali::Radian((const Dali::Radian &)result);
9612   return jresult;
9613 }
9614
9615
9616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9617   void * jresult ;
9618   Dali::Radian arg1 ;
9619   Dali::Radian *argp1 ;
9620   Dali::Radian result;
9621
9622   argp1 = (Dali::Radian *)jarg1;
9623   if (!argp1) {
9624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9625     return 0;
9626   }
9627   arg1 = *argp1;
9628   {
9629     try {
9630       result = Dali::operator -(arg1);
9631     } catch (std::out_of_range& e) {
9632       {
9633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9634       };
9635     } catch (std::exception& e) {
9636       {
9637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9638       };
9639     } catch (...) {
9640       {
9641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9642       };
9643     }
9644   }
9645   jresult = new Dali::Radian((const Dali::Radian &)result);
9646   return jresult;
9647 }
9648
9649
9650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9651   void * jresult ;
9652   Dali::Radian arg1 ;
9653   float arg2 ;
9654   float arg3 ;
9655   Dali::Radian *argp1 ;
9656   Dali::Radian result;
9657
9658   argp1 = (Dali::Radian *)jarg1;
9659   if (!argp1) {
9660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9661     return 0;
9662   }
9663   arg1 = *argp1;
9664   arg2 = (float)jarg2;
9665   arg3 = (float)jarg3;
9666   {
9667     try {
9668       result = Dali::Clamp(arg1,arg2,arg3);
9669     } catch (std::out_of_range& e) {
9670       {
9671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9672       };
9673     } catch (std::exception& e) {
9674       {
9675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9676       };
9677     } catch (...) {
9678       {
9679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9680       };
9681     }
9682   }
9683   jresult = new Dali::Radian((const Dali::Radian &)result);
9684   return jresult;
9685 }
9686
9687
9688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9689   void * jresult ;
9690   Dali::Quaternion *result = 0 ;
9691
9692   {
9693     try {
9694       result = (Dali::Quaternion *)new Dali::Quaternion();
9695     } catch (std::out_of_range& e) {
9696       {
9697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9698       };
9699     } catch (std::exception& e) {
9700       {
9701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9702       };
9703     } catch (...) {
9704       {
9705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9706       };
9707     }
9708   }
9709   jresult = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9715   void * jresult ;
9716   Dali::Radian arg1 ;
9717   Dali::Vector3 *arg2 = 0 ;
9718   Dali::Radian *argp1 ;
9719   Dali::Quaternion *result = 0 ;
9720
9721   argp1 = (Dali::Radian *)jarg1;
9722   if (!argp1) {
9723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9724     return 0;
9725   }
9726   arg1 = *argp1;
9727   arg2 = (Dali::Vector3 *)jarg2;
9728   if (!arg2) {
9729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9730     return 0;
9731   }
9732   {
9733     try {
9734       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9735     } catch (std::out_of_range& e) {
9736       {
9737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9738       };
9739     } catch (std::exception& e) {
9740       {
9741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9742       };
9743     } catch (...) {
9744       {
9745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9746       };
9747     }
9748   }
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9755   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9756
9757   arg1 = (Dali::Quaternion *)jarg1;
9758   {
9759     try {
9760       delete arg1;
9761     } catch (std::out_of_range& e) {
9762       {
9763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9764       };
9765     } catch (std::exception& e) {
9766       {
9767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9768       };
9769     } catch (...) {
9770       {
9771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9772       };
9773     }
9774   }
9775 }
9776
9777
9778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9779   void * jresult ;
9780   Dali::Quaternion *result = 0 ;
9781
9782   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9783   jresult = (void *)result;
9784   return jresult;
9785 }
9786
9787
9788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9789   unsigned int jresult ;
9790   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9791   bool result;
9792
9793   arg1 = (Dali::Quaternion *)jarg1;
9794   {
9795     try {
9796       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9797     } catch (std::out_of_range& e) {
9798       {
9799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9800       };
9801     } catch (std::exception& e) {
9802       {
9803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9804       };
9805     } catch (...) {
9806       {
9807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9808       };
9809     }
9810   }
9811   jresult = result;
9812   return jresult;
9813 }
9814
9815
9816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9817   unsigned int jresult ;
9818   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9819   Dali::Vector3 *arg2 = 0 ;
9820   Dali::Radian *arg3 = 0 ;
9821   bool result;
9822
9823   arg1 = (Dali::Quaternion *)jarg1;
9824   arg2 = (Dali::Vector3 *)jarg2;
9825   if (!arg2) {
9826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9827     return 0;
9828   }
9829   arg3 = (Dali::Radian *)jarg3;
9830   if (!arg3) {
9831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9832     return 0;
9833   }
9834   {
9835     try {
9836       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9837     } catch (std::out_of_range& e) {
9838       {
9839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9840       };
9841     } catch (std::exception& e) {
9842       {
9843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9844       };
9845     } catch (...) {
9846       {
9847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9848       };
9849     }
9850   }
9851   jresult = result;
9852   return jresult;
9853 }
9854
9855
9856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9857   void * jresult ;
9858   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9859   Dali::Quaternion *arg2 = 0 ;
9860   Dali::Quaternion result;
9861
9862   arg1 = (Dali::Quaternion *)jarg1;
9863   arg2 = (Dali::Quaternion *)jarg2;
9864   if (!arg2) {
9865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9866     return 0;
9867   }
9868   {
9869     try {
9870       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9871     } catch (std::out_of_range& e) {
9872       {
9873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9874       };
9875     } catch (std::exception& e) {
9876       {
9877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (...) {
9880       {
9881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9882       };
9883     }
9884   }
9885   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9886   return jresult;
9887 }
9888
9889
9890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9891   void * jresult ;
9892   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9893   Dali::Quaternion *arg2 = 0 ;
9894   Dali::Quaternion result;
9895
9896   arg1 = (Dali::Quaternion *)jarg1;
9897   arg2 = (Dali::Quaternion *)jarg2;
9898   if (!arg2) {
9899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9900     return 0;
9901   }
9902   {
9903     try {
9904       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9905     } catch (std::out_of_range& e) {
9906       {
9907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9908       };
9909     } catch (std::exception& e) {
9910       {
9911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9912       };
9913     } catch (...) {
9914       {
9915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9916       };
9917     }
9918   }
9919   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9920   return jresult;
9921 }
9922
9923
9924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9925   void * jresult ;
9926   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9927   Dali::Quaternion *arg2 = 0 ;
9928   Dali::Quaternion result;
9929
9930   arg1 = (Dali::Quaternion *)jarg1;
9931   arg2 = (Dali::Quaternion *)jarg2;
9932   if (!arg2) {
9933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9934     return 0;
9935   }
9936   {
9937     try {
9938       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9939     } catch (std::out_of_range& e) {
9940       {
9941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9942       };
9943     } catch (std::exception& e) {
9944       {
9945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9946       };
9947     } catch (...) {
9948       {
9949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9950       };
9951     }
9952   }
9953   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9954   return jresult;
9955 }
9956
9957
9958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9959   void * jresult ;
9960   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9961   Dali::Vector3 *arg2 = 0 ;
9962   Dali::Vector3 result;
9963
9964   arg1 = (Dali::Quaternion *)jarg1;
9965   arg2 = (Dali::Vector3 *)jarg2;
9966   if (!arg2) {
9967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9968     return 0;
9969   }
9970   {
9971     try {
9972       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9973     } catch (std::out_of_range& e) {
9974       {
9975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9976       };
9977     } catch (std::exception& e) {
9978       {
9979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9980       };
9981     } catch (...) {
9982       {
9983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9984       };
9985     }
9986   }
9987   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
9988   return jresult;
9989 }
9990
9991
9992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
9993   void * jresult ;
9994   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9995   Dali::Quaternion *arg2 = 0 ;
9996   Dali::Quaternion result;
9997
9998   arg1 = (Dali::Quaternion *)jarg1;
9999   arg2 = (Dali::Quaternion *)jarg2;
10000   if (!arg2) {
10001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10002     return 0;
10003   }
10004   {
10005     try {
10006       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10007     } catch (std::out_of_range& e) {
10008       {
10009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10010       };
10011     } catch (std::exception& e) {
10012       {
10013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10014       };
10015     } catch (...) {
10016       {
10017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10018       };
10019     }
10020   }
10021   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10022   return jresult;
10023 }
10024
10025
10026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10027   void * jresult ;
10028   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10029   float arg2 ;
10030   Dali::Quaternion result;
10031
10032   arg1 = (Dali::Quaternion *)jarg1;
10033   arg2 = (float)jarg2;
10034   {
10035     try {
10036       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10037     } catch (std::out_of_range& e) {
10038       {
10039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10040       };
10041     } catch (std::exception& e) {
10042       {
10043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10044       };
10045     } catch (...) {
10046       {
10047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10048       };
10049     }
10050   }
10051   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10052   return jresult;
10053 }
10054
10055
10056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10057   void * jresult ;
10058   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10059   float arg2 ;
10060   Dali::Quaternion result;
10061
10062   arg1 = (Dali::Quaternion *)jarg1;
10063   arg2 = (float)jarg2;
10064   {
10065     try {
10066       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10067     } catch (std::out_of_range& e) {
10068       {
10069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10070       };
10071     } catch (std::exception& e) {
10072       {
10073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10074       };
10075     } catch (...) {
10076       {
10077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10078       };
10079     }
10080   }
10081   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10082   return jresult;
10083 }
10084
10085
10086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10087   void * jresult ;
10088   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10089   Dali::Quaternion result;
10090
10091   arg1 = (Dali::Quaternion *)jarg1;
10092   {
10093     try {
10094       result = ((Dali::Quaternion const *)arg1)->operator -();
10095     } catch (std::out_of_range& e) {
10096       {
10097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10098       };
10099     } catch (std::exception& e) {
10100       {
10101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10102       };
10103     } catch (...) {
10104       {
10105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10106       };
10107     }
10108   }
10109   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10110   return jresult;
10111 }
10112
10113
10114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10115   void * jresult ;
10116   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10117   Dali::Quaternion *arg2 = 0 ;
10118   Dali::Quaternion *result = 0 ;
10119
10120   arg1 = (Dali::Quaternion *)jarg1;
10121   arg2 = (Dali::Quaternion *)jarg2;
10122   if (!arg2) {
10123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10124     return 0;
10125   }
10126   {
10127     try {
10128       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10129     } catch (std::out_of_range& e) {
10130       {
10131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10132       };
10133     } catch (std::exception& e) {
10134       {
10135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10136       };
10137     } catch (...) {
10138       {
10139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10140       };
10141     }
10142   }
10143   jresult = (void *)result;
10144   return jresult;
10145 }
10146
10147
10148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10149   void * jresult ;
10150   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10151   Dali::Quaternion *arg2 = 0 ;
10152   Dali::Quaternion *result = 0 ;
10153
10154   arg1 = (Dali::Quaternion *)jarg1;
10155   arg2 = (Dali::Quaternion *)jarg2;
10156   if (!arg2) {
10157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10158     return 0;
10159   }
10160   {
10161     try {
10162       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10163     } catch (std::out_of_range& e) {
10164       {
10165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10166       };
10167     } catch (std::exception& e) {
10168       {
10169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10170       };
10171     } catch (...) {
10172       {
10173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10174       };
10175     }
10176   }
10177   jresult = (void *)result;
10178   return jresult;
10179 }
10180
10181
10182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10183   void * jresult ;
10184   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10185   Dali::Quaternion *arg2 = 0 ;
10186   Dali::Quaternion *result = 0 ;
10187
10188   arg1 = (Dali::Quaternion *)jarg1;
10189   arg2 = (Dali::Quaternion *)jarg2;
10190   if (!arg2) {
10191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10192     return 0;
10193   }
10194   {
10195     try {
10196       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10197     } catch (std::out_of_range& e) {
10198       {
10199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10200       };
10201     } catch (std::exception& e) {
10202       {
10203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10204       };
10205     } catch (...) {
10206       {
10207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10208       };
10209     }
10210   }
10211   jresult = (void *)result;
10212   return jresult;
10213 }
10214
10215
10216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10217   void * jresult ;
10218   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10219   float arg2 ;
10220   Dali::Quaternion *result = 0 ;
10221
10222   arg1 = (Dali::Quaternion *)jarg1;
10223   arg2 = (float)jarg2;
10224   {
10225     try {
10226       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10227     } catch (std::out_of_range& e) {
10228       {
10229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10230       };
10231     } catch (std::exception& e) {
10232       {
10233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10234       };
10235     } catch (...) {
10236       {
10237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10238       };
10239     }
10240   }
10241   jresult = (void *)result;
10242   return jresult;
10243 }
10244
10245
10246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10247   void * jresult ;
10248   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10249   float arg2 ;
10250   Dali::Quaternion *result = 0 ;
10251
10252   arg1 = (Dali::Quaternion *)jarg1;
10253   arg2 = (float)jarg2;
10254   {
10255     try {
10256       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10257     } catch (std::out_of_range& e) {
10258       {
10259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10260       };
10261     } catch (std::exception& e) {
10262       {
10263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10264       };
10265     } catch (...) {
10266       {
10267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10268       };
10269     }
10270   }
10271   jresult = (void *)result;
10272   return jresult;
10273 }
10274
10275
10276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10277   unsigned int jresult ;
10278   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10279   Dali::Quaternion *arg2 = 0 ;
10280   bool result;
10281
10282   arg1 = (Dali::Quaternion *)jarg1;
10283   arg2 = (Dali::Quaternion *)jarg2;
10284   if (!arg2) {
10285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10286     return 0;
10287   }
10288   {
10289     try {
10290       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10291     } catch (std::out_of_range& e) {
10292       {
10293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10294       };
10295     } catch (std::exception& e) {
10296       {
10297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10298       };
10299     } catch (...) {
10300       {
10301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10302       };
10303     }
10304   }
10305   jresult = result;
10306   return jresult;
10307 }
10308
10309
10310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10311   unsigned int jresult ;
10312   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10313   Dali::Quaternion *arg2 = 0 ;
10314   bool result;
10315
10316   arg1 = (Dali::Quaternion *)jarg1;
10317   arg2 = (Dali::Quaternion *)jarg2;
10318   if (!arg2) {
10319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10320     return 0;
10321   }
10322   {
10323     try {
10324       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10325     } catch (std::out_of_range& e) {
10326       {
10327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10328       };
10329     } catch (std::exception& e) {
10330       {
10331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10332       };
10333     } catch (...) {
10334       {
10335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10336       };
10337     }
10338   }
10339   jresult = result;
10340   return jresult;
10341 }
10342
10343
10344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10345   float jresult ;
10346   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10347   float result;
10348
10349   arg1 = (Dali::Quaternion *)jarg1;
10350   {
10351     try {
10352       result = (float)((Dali::Quaternion const *)arg1)->Length();
10353     } catch (std::out_of_range& e) {
10354       {
10355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10356       };
10357     } catch (std::exception& e) {
10358       {
10359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10360       };
10361     } catch (...) {
10362       {
10363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10364       };
10365     }
10366   }
10367   jresult = result;
10368   return jresult;
10369 }
10370
10371
10372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10373   float jresult ;
10374   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10375   float result;
10376
10377   arg1 = (Dali::Quaternion *)jarg1;
10378   {
10379     try {
10380       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10381     } catch (std::out_of_range& e) {
10382       {
10383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10384       };
10385     } catch (std::exception& e) {
10386       {
10387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10388       };
10389     } catch (...) {
10390       {
10391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10392       };
10393     }
10394   }
10395   jresult = result;
10396   return jresult;
10397 }
10398
10399
10400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10401   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10402
10403   arg1 = (Dali::Quaternion *)jarg1;
10404   {
10405     try {
10406       (arg1)->Normalize();
10407     } catch (std::out_of_range& e) {
10408       {
10409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10410       };
10411     } catch (std::exception& e) {
10412       {
10413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10414       };
10415     } catch (...) {
10416       {
10417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10418       };
10419     }
10420   }
10421 }
10422
10423
10424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10425   void * jresult ;
10426   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10427   Dali::Quaternion result;
10428
10429   arg1 = (Dali::Quaternion *)jarg1;
10430   {
10431     try {
10432       result = ((Dali::Quaternion const *)arg1)->Normalized();
10433     } catch (std::out_of_range& e) {
10434       {
10435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10436       };
10437     } catch (std::exception& e) {
10438       {
10439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10440       };
10441     } catch (...) {
10442       {
10443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10444       };
10445     }
10446   }
10447   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10448   return jresult;
10449 }
10450
10451
10452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10453   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10454
10455   arg1 = (Dali::Quaternion *)jarg1;
10456   {
10457     try {
10458       (arg1)->Conjugate();
10459     } catch (std::out_of_range& e) {
10460       {
10461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10462       };
10463     } catch (std::exception& e) {
10464       {
10465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10466       };
10467     } catch (...) {
10468       {
10469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10470       };
10471     }
10472   }
10473 }
10474
10475
10476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10477   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10478
10479   arg1 = (Dali::Quaternion *)jarg1;
10480   {
10481     try {
10482       (arg1)->Invert();
10483     } catch (std::out_of_range& e) {
10484       {
10485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10486       };
10487     } catch (std::exception& e) {
10488       {
10489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10490       };
10491     } catch (...) {
10492       {
10493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10494       };
10495     }
10496   }
10497 }
10498
10499
10500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10501   void * jresult ;
10502   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10503   Dali::Quaternion result;
10504
10505   arg1 = (Dali::Quaternion *)jarg1;
10506   {
10507     try {
10508       result = ((Dali::Quaternion const *)arg1)->Log();
10509     } catch (std::out_of_range& e) {
10510       {
10511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10512       };
10513     } catch (std::exception& e) {
10514       {
10515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10516       };
10517     } catch (...) {
10518       {
10519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10520       };
10521     }
10522   }
10523   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10524   return jresult;
10525 }
10526
10527
10528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10529   void * jresult ;
10530   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10531   Dali::Quaternion result;
10532
10533   arg1 = (Dali::Quaternion *)jarg1;
10534   {
10535     try {
10536       result = ((Dali::Quaternion const *)arg1)->Exp();
10537     } catch (std::out_of_range& e) {
10538       {
10539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10540       };
10541     } catch (std::exception& e) {
10542       {
10543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10544       };
10545     } catch (...) {
10546       {
10547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10548       };
10549     }
10550   }
10551   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10552   return jresult;
10553 }
10554
10555
10556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10557   float jresult ;
10558   Dali::Quaternion *arg1 = 0 ;
10559   Dali::Quaternion *arg2 = 0 ;
10560   float result;
10561
10562   arg1 = (Dali::Quaternion *)jarg1;
10563   if (!arg1) {
10564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10565     return 0;
10566   }
10567   arg2 = (Dali::Quaternion *)jarg2;
10568   if (!arg2) {
10569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10570     return 0;
10571   }
10572   {
10573     try {
10574       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10575     } catch (std::out_of_range& e) {
10576       {
10577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10578       };
10579     } catch (std::exception& e) {
10580       {
10581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10582       };
10583     } catch (...) {
10584       {
10585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10586       };
10587     }
10588   }
10589   jresult = result;
10590   return jresult;
10591 }
10592
10593
10594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10595   void * jresult ;
10596   Dali::Quaternion *arg1 = 0 ;
10597   Dali::Quaternion *arg2 = 0 ;
10598   float arg3 ;
10599   Dali::Quaternion result;
10600
10601   arg1 = (Dali::Quaternion *)jarg1;
10602   if (!arg1) {
10603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10604     return 0;
10605   }
10606   arg2 = (Dali::Quaternion *)jarg2;
10607   if (!arg2) {
10608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10609     return 0;
10610   }
10611   arg3 = (float)jarg3;
10612   {
10613     try {
10614       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10615     } catch (std::out_of_range& e) {
10616       {
10617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10618       };
10619     } catch (std::exception& e) {
10620       {
10621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10622       };
10623     } catch (...) {
10624       {
10625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10626       };
10627     }
10628   }
10629   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10630   return jresult;
10631 }
10632
10633
10634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10635   void * jresult ;
10636   Dali::Quaternion *arg1 = 0 ;
10637   Dali::Quaternion *arg2 = 0 ;
10638   float arg3 ;
10639   Dali::Quaternion result;
10640
10641   arg1 = (Dali::Quaternion *)jarg1;
10642   if (!arg1) {
10643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10644     return 0;
10645   }
10646   arg2 = (Dali::Quaternion *)jarg2;
10647   if (!arg2) {
10648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10649     return 0;
10650   }
10651   arg3 = (float)jarg3;
10652   {
10653     try {
10654       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10655     } catch (std::out_of_range& e) {
10656       {
10657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (std::exception& e) {
10660       {
10661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10662       };
10663     } catch (...) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10666       };
10667     }
10668   }
10669   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10670   return jresult;
10671 }
10672
10673
10674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10675   void * jresult ;
10676   Dali::Quaternion *arg1 = 0 ;
10677   Dali::Quaternion *arg2 = 0 ;
10678   float arg3 ;
10679   Dali::Quaternion result;
10680
10681   arg1 = (Dali::Quaternion *)jarg1;
10682   if (!arg1) {
10683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10684     return 0;
10685   }
10686   arg2 = (Dali::Quaternion *)jarg2;
10687   if (!arg2) {
10688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10689     return 0;
10690   }
10691   arg3 = (float)jarg3;
10692   {
10693     try {
10694       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10695     } catch (std::out_of_range& e) {
10696       {
10697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10698       };
10699     } catch (std::exception& e) {
10700       {
10701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10702       };
10703     } catch (...) {
10704       {
10705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10706       };
10707     }
10708   }
10709   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10710   return jresult;
10711 }
10712
10713
10714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10715   void * jresult ;
10716   Dali::Quaternion *arg1 = 0 ;
10717   Dali::Quaternion *arg2 = 0 ;
10718   Dali::Quaternion *arg3 = 0 ;
10719   Dali::Quaternion *arg4 = 0 ;
10720   float arg5 ;
10721   Dali::Quaternion result;
10722
10723   arg1 = (Dali::Quaternion *)jarg1;
10724   if (!arg1) {
10725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10726     return 0;
10727   }
10728   arg2 = (Dali::Quaternion *)jarg2;
10729   if (!arg2) {
10730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10731     return 0;
10732   }
10733   arg3 = (Dali::Quaternion *)jarg3;
10734   if (!arg3) {
10735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10736     return 0;
10737   }
10738   arg4 = (Dali::Quaternion *)jarg4;
10739   if (!arg4) {
10740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10741     return 0;
10742   }
10743   arg5 = (float)jarg5;
10744   {
10745     try {
10746       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10747     } catch (std::out_of_range& e) {
10748       {
10749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (std::exception& e) {
10752       {
10753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10754       };
10755     } catch (...) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10758       };
10759     }
10760   }
10761   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10762   return jresult;
10763 }
10764
10765
10766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10767   float jresult ;
10768   Dali::Quaternion *arg1 = 0 ;
10769   Dali::Quaternion *arg2 = 0 ;
10770   float result;
10771
10772   arg1 = (Dali::Quaternion *)jarg1;
10773   if (!arg1) {
10774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10775     return 0;
10776   }
10777   arg2 = (Dali::Quaternion *)jarg2;
10778   if (!arg2) {
10779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10780     return 0;
10781   }
10782   {
10783     try {
10784       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10785     } catch (std::out_of_range& e) {
10786       {
10787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10788       };
10789     } catch (std::exception& e) {
10790       {
10791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10792       };
10793     } catch (...) {
10794       {
10795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10796       };
10797     }
10798   }
10799   jresult = result;
10800   return jresult;
10801 }
10802
10803
10804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10805   void * jresult ;
10806   Dali::Matrix *result = 0 ;
10807
10808   {
10809     try {
10810       result = (Dali::Matrix *)new Dali::Matrix();
10811     } catch (std::out_of_range& e) {
10812       {
10813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10814       };
10815     } catch (std::exception& e) {
10816       {
10817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10818       };
10819     } catch (...) {
10820       {
10821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10822       };
10823     }
10824   }
10825   jresult = (void *)result;
10826   return jresult;
10827 }
10828
10829
10830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10831   void * jresult ;
10832   bool arg1 ;
10833   Dali::Matrix *result = 0 ;
10834
10835   arg1 = jarg1 ? true : false;
10836   {
10837     try {
10838       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10839     } catch (std::out_of_range& e) {
10840       {
10841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10842       };
10843     } catch (std::exception& e) {
10844       {
10845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10846       };
10847     } catch (...) {
10848       {
10849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10850       };
10851     }
10852   }
10853   jresult = (void *)result;
10854   return jresult;
10855 }
10856
10857
10858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10859   void * jresult ;
10860   float *arg1 = (float *) 0 ;
10861   Dali::Matrix *result = 0 ;
10862
10863   arg1 = jarg1;
10864   {
10865     try {
10866       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10867     } catch (std::out_of_range& e) {
10868       {
10869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10870       };
10871     } catch (std::exception& e) {
10872       {
10873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10874       };
10875     } catch (...) {
10876       {
10877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10878       };
10879     }
10880   }
10881   jresult = (void *)result;
10882
10883
10884   return jresult;
10885 }
10886
10887
10888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10889   void * jresult ;
10890   Dali::Quaternion *arg1 = 0 ;
10891   Dali::Matrix *result = 0 ;
10892
10893   arg1 = (Dali::Quaternion *)jarg1;
10894   if (!arg1) {
10895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10896     return 0;
10897   }
10898   {
10899     try {
10900       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10901     } catch (std::out_of_range& e) {
10902       {
10903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (std::exception& e) {
10906       {
10907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10908       };
10909     } catch (...) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10912       };
10913     }
10914   }
10915   jresult = (void *)result;
10916   return jresult;
10917 }
10918
10919
10920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10921   void * jresult ;
10922   Dali::Matrix *arg1 = 0 ;
10923   Dali::Matrix *result = 0 ;
10924
10925   arg1 = (Dali::Matrix *)jarg1;
10926   if (!arg1) {
10927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10928     return 0;
10929   }
10930   {
10931     try {
10932       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10933     } catch (std::out_of_range& e) {
10934       {
10935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10936       };
10937     } catch (std::exception& e) {
10938       {
10939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10940       };
10941     } catch (...) {
10942       {
10943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10944       };
10945     }
10946   }
10947   jresult = (void *)result;
10948   return jresult;
10949 }
10950
10951
10952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10953   void * jresult ;
10954   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10955   Dali::Matrix *arg2 = 0 ;
10956   Dali::Matrix *result = 0 ;
10957
10958   arg1 = (Dali::Matrix *)jarg1;
10959   arg2 = (Dali::Matrix *)jarg2;
10960   if (!arg2) {
10961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10962     return 0;
10963   }
10964   {
10965     try {
10966       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10967     } catch (std::out_of_range& e) {
10968       {
10969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10970       };
10971     } catch (std::exception& e) {
10972       {
10973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10974       };
10975     } catch (...) {
10976       {
10977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10978       };
10979     }
10980   }
10981   jresult = (void *)result;
10982   return jresult;
10983 }
10984
10985
10986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
10987   void * jresult ;
10988   Dali::Matrix *result = 0 ;
10989
10990   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
10991   jresult = (void *)result;
10992   return jresult;
10993 }
10994
10995
10996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
10997   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10998
10999   arg1 = (Dali::Matrix *)jarg1;
11000   {
11001     try {
11002       (arg1)->SetIdentity();
11003     } catch (std::out_of_range& e) {
11004       {
11005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11006       };
11007     } catch (std::exception& e) {
11008       {
11009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11010       };
11011     } catch (...) {
11012       {
11013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11014       };
11015     }
11016   }
11017 }
11018
11019
11020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11021   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11022   Dali::Vector3 *arg2 = 0 ;
11023
11024   arg1 = (Dali::Matrix *)jarg1;
11025   arg2 = (Dali::Vector3 *)jarg2;
11026   if (!arg2) {
11027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11028     return ;
11029   }
11030   {
11031     try {
11032       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11033     } catch (std::out_of_range& e) {
11034       {
11035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11036       };
11037     } catch (std::exception& e) {
11038       {
11039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11040       };
11041     } catch (...) {
11042       {
11043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11044       };
11045     }
11046   }
11047 }
11048
11049
11050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11051   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11052   Dali::Matrix *arg2 = 0 ;
11053
11054   arg1 = (Dali::Matrix *)jarg1;
11055   arg2 = (Dali::Matrix *)jarg2;
11056   if (!arg2) {
11057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11058     return ;
11059   }
11060   {
11061     try {
11062       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11063     } catch (std::out_of_range& e) {
11064       {
11065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11066       };
11067     } catch (std::exception& e) {
11068       {
11069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11070       };
11071     } catch (...) {
11072       {
11073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11074       };
11075     }
11076   }
11077 }
11078
11079
11080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11081   unsigned int jresult ;
11082   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11083   bool result;
11084
11085   arg1 = (Dali::Matrix *)jarg1;
11086   {
11087     try {
11088       result = (bool)(arg1)->Invert();
11089     } catch (std::out_of_range& e) {
11090       {
11091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11092       };
11093     } catch (std::exception& e) {
11094       {
11095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11096       };
11097     } catch (...) {
11098       {
11099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11100       };
11101     }
11102   }
11103   jresult = result;
11104   return jresult;
11105 }
11106
11107
11108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11109   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11110
11111   arg1 = (Dali::Matrix *)jarg1;
11112   {
11113     try {
11114       (arg1)->Transpose();
11115     } catch (std::out_of_range& e) {
11116       {
11117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11118       };
11119     } catch (std::exception& e) {
11120       {
11121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11122       };
11123     } catch (...) {
11124       {
11125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11126       };
11127     }
11128   }
11129 }
11130
11131
11132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11133   void * jresult ;
11134   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11135   Dali::Vector3 result;
11136
11137   arg1 = (Dali::Matrix *)jarg1;
11138   {
11139     try {
11140       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11141     } catch (std::out_of_range& e) {
11142       {
11143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11144       };
11145     } catch (std::exception& e) {
11146       {
11147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11148       };
11149     } catch (...) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11152       };
11153     }
11154   }
11155   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11156   return jresult;
11157 }
11158
11159
11160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11161   void * jresult ;
11162   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11163   Dali::Vector3 result;
11164
11165   arg1 = (Dali::Matrix *)jarg1;
11166   {
11167     try {
11168       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11169     } catch (std::out_of_range& e) {
11170       {
11171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11172       };
11173     } catch (std::exception& e) {
11174       {
11175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11176       };
11177     } catch (...) {
11178       {
11179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11180       };
11181     }
11182   }
11183   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11184   return jresult;
11185 }
11186
11187
11188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11189   void * jresult ;
11190   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11191   Dali::Vector3 result;
11192
11193   arg1 = (Dali::Matrix *)jarg1;
11194   {
11195     try {
11196       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11197     } catch (std::out_of_range& e) {
11198       {
11199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11200       };
11201     } catch (std::exception& e) {
11202       {
11203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11204       };
11205     } catch (...) {
11206       {
11207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11208       };
11209     }
11210   }
11211   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11212   return jresult;
11213 }
11214
11215
11216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11217   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11218   Dali::Vector3 *arg2 = 0 ;
11219
11220   arg1 = (Dali::Matrix *)jarg1;
11221   arg2 = (Dali::Vector3 *)jarg2;
11222   if (!arg2) {
11223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11224     return ;
11225   }
11226   {
11227     try {
11228       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11229     } catch (std::out_of_range& e) {
11230       {
11231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11232       };
11233     } catch (std::exception& e) {
11234       {
11235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11236       };
11237     } catch (...) {
11238       {
11239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11240       };
11241     }
11242   }
11243 }
11244
11245
11246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11247   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11248   Dali::Vector3 *arg2 = 0 ;
11249
11250   arg1 = (Dali::Matrix *)jarg1;
11251   arg2 = (Dali::Vector3 *)jarg2;
11252   if (!arg2) {
11253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11254     return ;
11255   }
11256   {
11257     try {
11258       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11259     } catch (std::out_of_range& e) {
11260       {
11261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11262       };
11263     } catch (std::exception& e) {
11264       {
11265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11266       };
11267     } catch (...) {
11268       {
11269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11270       };
11271     }
11272   }
11273 }
11274
11275
11276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11277   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11278   Dali::Vector3 *arg2 = 0 ;
11279
11280   arg1 = (Dali::Matrix *)jarg1;
11281   arg2 = (Dali::Vector3 *)jarg2;
11282   if (!arg2) {
11283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11284     return ;
11285   }
11286   {
11287     try {
11288       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11289     } catch (std::out_of_range& e) {
11290       {
11291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11292       };
11293     } catch (std::exception& e) {
11294       {
11295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11296       };
11297     } catch (...) {
11298       {
11299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11300       };
11301     }
11302   }
11303 }
11304
11305
11306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11307   void * jresult ;
11308   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11309   Dali::Vector4 *result = 0 ;
11310
11311   arg1 = (Dali::Matrix *)jarg1;
11312   {
11313     try {
11314       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11315     } catch (std::out_of_range& e) {
11316       {
11317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11318       };
11319     } catch (std::exception& e) {
11320       {
11321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11322       };
11323     } catch (...) {
11324       {
11325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11326       };
11327     }
11328   }
11329   jresult = (void *)result;
11330   return jresult;
11331 }
11332
11333
11334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11335   void * jresult ;
11336   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11337   Dali::Vector3 *result = 0 ;
11338
11339   arg1 = (Dali::Matrix *)jarg1;
11340   {
11341     try {
11342       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11343     } catch (std::out_of_range& e) {
11344       {
11345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11346       };
11347     } catch (std::exception& e) {
11348       {
11349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11350       };
11351     } catch (...) {
11352       {
11353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11354       };
11355     }
11356   }
11357   jresult = (void *)result;
11358   return jresult;
11359 }
11360
11361
11362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11363   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11364   Dali::Vector4 *arg2 = 0 ;
11365
11366   arg1 = (Dali::Matrix *)jarg1;
11367   arg2 = (Dali::Vector4 *)jarg2;
11368   if (!arg2) {
11369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11370     return ;
11371   }
11372   {
11373     try {
11374       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11375     } catch (std::out_of_range& e) {
11376       {
11377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11378       };
11379     } catch (std::exception& e) {
11380       {
11381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11382       };
11383     } catch (...) {
11384       {
11385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11386       };
11387     }
11388   }
11389 }
11390
11391
11392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11393   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11394   Dali::Vector3 *arg2 = 0 ;
11395
11396   arg1 = (Dali::Matrix *)jarg1;
11397   arg2 = (Dali::Vector3 *)jarg2;
11398   if (!arg2) {
11399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11400     return ;
11401   }
11402   {
11403     try {
11404       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11405     } catch (std::out_of_range& e) {
11406       {
11407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11408       };
11409     } catch (std::exception& e) {
11410       {
11411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11412       };
11413     } catch (...) {
11414       {
11415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11416       };
11417     }
11418   }
11419 }
11420
11421
11422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11423   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11424
11425   arg1 = (Dali::Matrix *)jarg1;
11426   {
11427     try {
11428       (arg1)->OrthoNormalize();
11429     } catch (std::out_of_range& e) {
11430       {
11431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11432       };
11433     } catch (std::exception& e) {
11434       {
11435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11436       };
11437     } catch (...) {
11438       {
11439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11440       };
11441     }
11442   }
11443 }
11444
11445
11446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11447   void * jresult ;
11448   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11449   float *result = 0 ;
11450
11451   arg1 = (Dali::Matrix *)jarg1;
11452   {
11453     try {
11454       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11455     } catch (std::out_of_range& e) {
11456       {
11457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11458       };
11459     } catch (std::exception& e) {
11460       {
11461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11462       };
11463     } catch (...) {
11464       {
11465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11466       };
11467     }
11468   }
11469   jresult = (void *)result;
11470   return jresult;
11471 }
11472
11473
11474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11475   Dali::Matrix *arg1 = 0 ;
11476   Dali::Matrix *arg2 = 0 ;
11477   Dali::Matrix *arg3 = 0 ;
11478
11479   arg1 = (Dali::Matrix *)jarg1;
11480   if (!arg1) {
11481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11482     return ;
11483   }
11484   arg2 = (Dali::Matrix *)jarg2;
11485   if (!arg2) {
11486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11487     return ;
11488   }
11489   arg3 = (Dali::Matrix *)jarg3;
11490   if (!arg3) {
11491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11492     return ;
11493   }
11494   {
11495     try {
11496       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11497     } catch (std::out_of_range& e) {
11498       {
11499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11500       };
11501     } catch (std::exception& e) {
11502       {
11503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11504       };
11505     } catch (...) {
11506       {
11507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11508       };
11509     }
11510   }
11511 }
11512
11513
11514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11515   Dali::Matrix *arg1 = 0 ;
11516   Dali::Matrix *arg2 = 0 ;
11517   Dali::Quaternion *arg3 = 0 ;
11518
11519   arg1 = (Dali::Matrix *)jarg1;
11520   if (!arg1) {
11521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11522     return ;
11523   }
11524   arg2 = (Dali::Matrix *)jarg2;
11525   if (!arg2) {
11526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11527     return ;
11528   }
11529   arg3 = (Dali::Quaternion *)jarg3;
11530   if (!arg3) {
11531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11532     return ;
11533   }
11534   {
11535     try {
11536       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11537     } catch (std::out_of_range& e) {
11538       {
11539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11540       };
11541     } catch (std::exception& e) {
11542       {
11543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11544       };
11545     } catch (...) {
11546       {
11547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11548       };
11549     }
11550   }
11551 }
11552
11553
11554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11555   void * jresult ;
11556   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11557   Dali::Vector4 *arg2 = 0 ;
11558   Dali::Vector4 result;
11559
11560   arg1 = (Dali::Matrix *)jarg1;
11561   arg2 = (Dali::Vector4 *)jarg2;
11562   if (!arg2) {
11563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11564     return 0;
11565   }
11566   {
11567     try {
11568       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11569     } catch (std::out_of_range& e) {
11570       {
11571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11572       };
11573     } catch (std::exception& e) {
11574       {
11575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11576       };
11577     } catch (...) {
11578       {
11579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11580       };
11581     }
11582   }
11583   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11584   return jresult;
11585 }
11586
11587
11588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11589   unsigned int jresult ;
11590   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11591   Dali::Matrix *arg2 = 0 ;
11592   bool result;
11593
11594   arg1 = (Dali::Matrix *)jarg1;
11595   arg2 = (Dali::Matrix *)jarg2;
11596   if (!arg2) {
11597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11598     return 0;
11599   }
11600   {
11601     try {
11602       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11603     } catch (std::out_of_range& e) {
11604       {
11605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11606       };
11607     } catch (std::exception& e) {
11608       {
11609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11610       };
11611     } catch (...) {
11612       {
11613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11614       };
11615     }
11616   }
11617   jresult = result;
11618   return jresult;
11619 }
11620
11621
11622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11623   unsigned int jresult ;
11624   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11625   Dali::Matrix *arg2 = 0 ;
11626   bool result;
11627
11628   arg1 = (Dali::Matrix *)jarg1;
11629   arg2 = (Dali::Matrix *)jarg2;
11630   if (!arg2) {
11631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11632     return 0;
11633   }
11634   {
11635     try {
11636       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11637     } catch (std::out_of_range& e) {
11638       {
11639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11640       };
11641     } catch (std::exception& e) {
11642       {
11643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11644       };
11645     } catch (...) {
11646       {
11647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11648       };
11649     }
11650   }
11651   jresult = result;
11652   return jresult;
11653 }
11654
11655
11656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11657   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11658   Dali::Vector3 *arg2 = 0 ;
11659   Dali::Quaternion *arg3 = 0 ;
11660   Dali::Vector3 *arg4 = 0 ;
11661
11662   arg1 = (Dali::Matrix *)jarg1;
11663   arg2 = (Dali::Vector3 *)jarg2;
11664   if (!arg2) {
11665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11666     return ;
11667   }
11668   arg3 = (Dali::Quaternion *)jarg3;
11669   if (!arg3) {
11670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11671     return ;
11672   }
11673   arg4 = (Dali::Vector3 *)jarg4;
11674   if (!arg4) {
11675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11676     return ;
11677   }
11678   {
11679     try {
11680       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11681     } catch (std::out_of_range& e) {
11682       {
11683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11684       };
11685     } catch (std::exception& e) {
11686       {
11687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11688       };
11689     } catch (...) {
11690       {
11691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11692       };
11693     }
11694   }
11695 }
11696
11697
11698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11699   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11700   Dali::Vector3 *arg2 = 0 ;
11701   Dali::Quaternion *arg3 = 0 ;
11702   Dali::Vector3 *arg4 = 0 ;
11703
11704   arg1 = (Dali::Matrix *)jarg1;
11705   arg2 = (Dali::Vector3 *)jarg2;
11706   if (!arg2) {
11707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11708     return ;
11709   }
11710   arg3 = (Dali::Quaternion *)jarg3;
11711   if (!arg3) {
11712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11713     return ;
11714   }
11715   arg4 = (Dali::Vector3 *)jarg4;
11716   if (!arg4) {
11717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11718     return ;
11719   }
11720   {
11721     try {
11722       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11723     } catch (std::out_of_range& e) {
11724       {
11725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11726       };
11727     } catch (std::exception& e) {
11728       {
11729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11730       };
11731     } catch (...) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11734       };
11735     }
11736   }
11737 }
11738
11739
11740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11741   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11742   Dali::Vector3 *arg2 = 0 ;
11743   Dali::Vector3 *arg3 = 0 ;
11744   Dali::Vector3 *arg4 = 0 ;
11745   Dali::Vector3 *arg5 = 0 ;
11746
11747   arg1 = (Dali::Matrix *)jarg1;
11748   arg2 = (Dali::Vector3 *)jarg2;
11749   if (!arg2) {
11750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11751     return ;
11752   }
11753   arg3 = (Dali::Vector3 *)jarg3;
11754   if (!arg3) {
11755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11756     return ;
11757   }
11758   arg4 = (Dali::Vector3 *)jarg4;
11759   if (!arg4) {
11760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11761     return ;
11762   }
11763   arg5 = (Dali::Vector3 *)jarg5;
11764   if (!arg5) {
11765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11766     return ;
11767   }
11768   {
11769     try {
11770       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11771     } catch (std::out_of_range& e) {
11772       {
11773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11774       };
11775     } catch (std::exception& e) {
11776       {
11777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11778       };
11779     } catch (...) {
11780       {
11781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11782       };
11783     }
11784   }
11785 }
11786
11787
11788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11789   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11790   Dali::Vector3 *arg2 = 0 ;
11791   Dali::Quaternion *arg3 = 0 ;
11792   Dali::Vector3 *arg4 = 0 ;
11793
11794   arg1 = (Dali::Matrix *)jarg1;
11795   arg2 = (Dali::Vector3 *)jarg2;
11796   if (!arg2) {
11797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11798     return ;
11799   }
11800   arg3 = (Dali::Quaternion *)jarg3;
11801   if (!arg3) {
11802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11803     return ;
11804   }
11805   arg4 = (Dali::Vector3 *)jarg4;
11806   if (!arg4) {
11807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11808     return ;
11809   }
11810   {
11811     try {
11812       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11813     } catch (std::out_of_range& e) {
11814       {
11815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11816       };
11817     } catch (std::exception& e) {
11818       {
11819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11820       };
11821     } catch (...) {
11822       {
11823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11824       };
11825     }
11826   }
11827 }
11828
11829
11830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11831   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11832
11833   arg1 = (Dali::Matrix *)jarg1;
11834   {
11835     try {
11836       delete arg1;
11837     } catch (std::out_of_range& e) {
11838       {
11839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11840       };
11841     } catch (std::exception& e) {
11842       {
11843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11844       };
11845     } catch (...) {
11846       {
11847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11848       };
11849     }
11850   }
11851 }
11852
11853
11854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11855   void * jresult ;
11856   Dali::Matrix3 *result = 0 ;
11857
11858   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11859   jresult = (void *)result;
11860   return jresult;
11861 }
11862
11863
11864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11865   void * jresult ;
11866   Dali::Matrix3 *result = 0 ;
11867
11868   {
11869     try {
11870       result = (Dali::Matrix3 *)new Dali::Matrix3();
11871     } catch (std::out_of_range& e) {
11872       {
11873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11874       };
11875     } catch (std::exception& e) {
11876       {
11877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11878       };
11879     } catch (...) {
11880       {
11881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11882       };
11883     }
11884   }
11885   jresult = (void *)result;
11886   return jresult;
11887 }
11888
11889
11890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11891   void * jresult ;
11892   Dali::Matrix3 *arg1 = 0 ;
11893   Dali::Matrix3 *result = 0 ;
11894
11895   arg1 = (Dali::Matrix3 *)jarg1;
11896   if (!arg1) {
11897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11898     return 0;
11899   }
11900   {
11901     try {
11902       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11903     } catch (std::out_of_range& e) {
11904       {
11905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11906       };
11907     } catch (std::exception& e) {
11908       {
11909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11910       };
11911     } catch (...) {
11912       {
11913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11914       };
11915     }
11916   }
11917   jresult = (void *)result;
11918   return jresult;
11919 }
11920
11921
11922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11923   void * jresult ;
11924   Dali::Matrix *arg1 = 0 ;
11925   Dali::Matrix3 *result = 0 ;
11926
11927   arg1 = (Dali::Matrix *)jarg1;
11928   if (!arg1) {
11929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11930     return 0;
11931   }
11932   {
11933     try {
11934       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11935     } catch (std::out_of_range& e) {
11936       {
11937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11938       };
11939     } catch (std::exception& e) {
11940       {
11941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11942       };
11943     } catch (...) {
11944       {
11945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11946       };
11947     }
11948   }
11949   jresult = (void *)result;
11950   return jresult;
11951 }
11952
11953
11954 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) {
11955   void * jresult ;
11956   float arg1 ;
11957   float arg2 ;
11958   float arg3 ;
11959   float arg4 ;
11960   float arg5 ;
11961   float arg6 ;
11962   float arg7 ;
11963   float arg8 ;
11964   float arg9 ;
11965   Dali::Matrix3 *result = 0 ;
11966
11967   arg1 = (float)jarg1;
11968   arg2 = (float)jarg2;
11969   arg3 = (float)jarg3;
11970   arg4 = (float)jarg4;
11971   arg5 = (float)jarg5;
11972   arg6 = (float)jarg6;
11973   arg7 = (float)jarg7;
11974   arg8 = (float)jarg8;
11975   arg9 = (float)jarg9;
11976   {
11977     try {
11978       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11979     } catch (std::out_of_range& e) {
11980       {
11981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11982       };
11983     } catch (std::exception& e) {
11984       {
11985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11986       };
11987     } catch (...) {
11988       {
11989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11990       };
11991     }
11992   }
11993   jresult = (void *)result;
11994   return jresult;
11995 }
11996
11997
11998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
11999   void * jresult ;
12000   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12001   Dali::Matrix3 *arg2 = 0 ;
12002   Dali::Matrix3 *result = 0 ;
12003
12004   arg1 = (Dali::Matrix3 *)jarg1;
12005   arg2 = (Dali::Matrix3 *)jarg2;
12006   if (!arg2) {
12007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12008     return 0;
12009   }
12010   {
12011     try {
12012       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (...) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12024       };
12025     }
12026   }
12027   jresult = (void *)result;
12028   return jresult;
12029 }
12030
12031
12032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12033   void * jresult ;
12034   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12035   Dali::Matrix *arg2 = 0 ;
12036   Dali::Matrix3 *result = 0 ;
12037
12038   arg1 = (Dali::Matrix3 *)jarg1;
12039   arg2 = (Dali::Matrix *)jarg2;
12040   if (!arg2) {
12041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12042     return 0;
12043   }
12044   {
12045     try {
12046       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12047     } catch (std::out_of_range& e) {
12048       {
12049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12050       };
12051     } catch (std::exception& e) {
12052       {
12053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12054       };
12055     } catch (...) {
12056       {
12057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12058       };
12059     }
12060   }
12061   jresult = (void *)result;
12062   return jresult;
12063 }
12064
12065
12066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12067   unsigned int jresult ;
12068   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12069   Dali::Matrix3 *arg2 = 0 ;
12070   bool result;
12071
12072   arg1 = (Dali::Matrix3 *)jarg1;
12073   arg2 = (Dali::Matrix3 *)jarg2;
12074   if (!arg2) {
12075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12076     return 0;
12077   }
12078   {
12079     try {
12080       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12081     } catch (std::out_of_range& e) {
12082       {
12083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12084       };
12085     } catch (std::exception& e) {
12086       {
12087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12088       };
12089     } catch (...) {
12090       {
12091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12092       };
12093     }
12094   }
12095   jresult = result;
12096   return jresult;
12097 }
12098
12099
12100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12101   unsigned int jresult ;
12102   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12103   Dali::Matrix3 *arg2 = 0 ;
12104   bool result;
12105
12106   arg1 = (Dali::Matrix3 *)jarg1;
12107   arg2 = (Dali::Matrix3 *)jarg2;
12108   if (!arg2) {
12109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12110     return 0;
12111   }
12112   {
12113     try {
12114       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12115     } catch (std::out_of_range& e) {
12116       {
12117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (std::exception& e) {
12120       {
12121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12122       };
12123     } catch (...) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12126       };
12127     }
12128   }
12129   jresult = result;
12130   return jresult;
12131 }
12132
12133
12134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12135   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12136
12137   arg1 = (Dali::Matrix3 *)jarg1;
12138   {
12139     try {
12140       delete arg1;
12141     } catch (std::out_of_range& e) {
12142       {
12143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12144       };
12145     } catch (std::exception& e) {
12146       {
12147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12148       };
12149     } catch (...) {
12150       {
12151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12152       };
12153     }
12154   }
12155 }
12156
12157
12158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12159   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12160
12161   arg1 = (Dali::Matrix3 *)jarg1;
12162   {
12163     try {
12164       (arg1)->SetIdentity();
12165     } catch (std::out_of_range& e) {
12166       {
12167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12168       };
12169     } catch (std::exception& e) {
12170       {
12171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12172       };
12173     } catch (...) {
12174       {
12175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12176       };
12177     }
12178   }
12179 }
12180
12181
12182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12183   void * jresult ;
12184   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12185   float *result = 0 ;
12186
12187   arg1 = (Dali::Matrix3 *)jarg1;
12188   {
12189     try {
12190       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12191     } catch (std::out_of_range& e) {
12192       {
12193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12194       };
12195     } catch (std::exception& e) {
12196       {
12197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12198       };
12199     } catch (...) {
12200       {
12201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12202       };
12203     }
12204   }
12205   jresult = (void *)result;
12206   return jresult;
12207 }
12208
12209
12210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12211   unsigned int jresult ;
12212   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12213   bool result;
12214
12215   arg1 = (Dali::Matrix3 *)jarg1;
12216   {
12217     try {
12218       result = (bool)(arg1)->Invert();
12219     } catch (std::out_of_range& e) {
12220       {
12221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12222       };
12223     } catch (std::exception& e) {
12224       {
12225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12226       };
12227     } catch (...) {
12228       {
12229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12230       };
12231     }
12232   }
12233   jresult = result;
12234   return jresult;
12235 }
12236
12237
12238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12239   unsigned int jresult ;
12240   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12241   bool result;
12242
12243   arg1 = (Dali::Matrix3 *)jarg1;
12244   {
12245     try {
12246       result = (bool)(arg1)->Transpose();
12247     } catch (std::out_of_range& e) {
12248       {
12249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12250       };
12251     } catch (std::exception& e) {
12252       {
12253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12254       };
12255     } catch (...) {
12256       {
12257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12258       };
12259     }
12260   }
12261   jresult = result;
12262   return jresult;
12263 }
12264
12265
12266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12267   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12268   float arg2 ;
12269
12270   arg1 = (Dali::Matrix3 *)jarg1;
12271   arg2 = (float)jarg2;
12272   {
12273     try {
12274       (arg1)->Scale(arg2);
12275     } catch (std::out_of_range& e) {
12276       {
12277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12278       };
12279     } catch (std::exception& e) {
12280       {
12281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12282       };
12283     } catch (...) {
12284       {
12285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12286       };
12287     }
12288   }
12289 }
12290
12291
12292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12293   float jresult ;
12294   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12295   float result;
12296
12297   arg1 = (Dali::Matrix3 *)jarg1;
12298   {
12299     try {
12300       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12301     } catch (std::out_of_range& e) {
12302       {
12303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12304       };
12305     } catch (std::exception& e) {
12306       {
12307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12308       };
12309     } catch (...) {
12310       {
12311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12312       };
12313     }
12314   }
12315   jresult = result;
12316   return jresult;
12317 }
12318
12319
12320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12321   unsigned int jresult ;
12322   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12323   bool result;
12324
12325   arg1 = (Dali::Matrix3 *)jarg1;
12326   {
12327     try {
12328       result = (bool)(arg1)->ScaledInverseTranspose();
12329     } catch (std::out_of_range& e) {
12330       {
12331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (std::exception& e) {
12334       {
12335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12336       };
12337     } catch (...) {
12338       {
12339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12340       };
12341     }
12342   }
12343   jresult = result;
12344   return jresult;
12345 }
12346
12347
12348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12349   Dali::Matrix3 *arg1 = 0 ;
12350   Dali::Matrix3 *arg2 = 0 ;
12351   Dali::Matrix3 *arg3 = 0 ;
12352
12353   arg1 = (Dali::Matrix3 *)jarg1;
12354   if (!arg1) {
12355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12356     return ;
12357   }
12358   arg2 = (Dali::Matrix3 *)jarg2;
12359   if (!arg2) {
12360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12361     return ;
12362   }
12363   arg3 = (Dali::Matrix3 *)jarg3;
12364   if (!arg3) {
12365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12366     return ;
12367   }
12368   {
12369     try {
12370       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12371     } catch (std::out_of_range& e) {
12372       {
12373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12374       };
12375     } catch (std::exception& e) {
12376       {
12377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12378       };
12379     } catch (...) {
12380       {
12381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12382       };
12383     }
12384   }
12385 }
12386
12387
12388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12389   float jresult ;
12390   float arg1 ;
12391   float arg2 ;
12392   float result;
12393
12394   arg1 = (float)jarg1;
12395   arg2 = (float)jarg2;
12396   {
12397     try {
12398       result = (float)Dali::Random::Range(arg1,arg2);
12399     } catch (std::out_of_range& e) {
12400       {
12401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12402       };
12403     } catch (std::exception& e) {
12404       {
12405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12406       };
12407     } catch (...) {
12408       {
12409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12410       };
12411     }
12412   }
12413   jresult = result;
12414   return jresult;
12415 }
12416
12417
12418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12419   void * jresult ;
12420   Dali::Vector4 result;
12421
12422   {
12423     try {
12424       result = Dali::Random::Axis();
12425     } catch (std::out_of_range& e) {
12426       {
12427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12428       };
12429     } catch (std::exception& e) {
12430       {
12431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12432       };
12433     } catch (...) {
12434       {
12435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12436       };
12437     }
12438   }
12439   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12440   return jresult;
12441 }
12442
12443
12444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12445   void * jresult ;
12446   Dali::AngleAxis *result = 0 ;
12447
12448   {
12449     try {
12450       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12451     } catch (std::out_of_range& e) {
12452       {
12453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12454       };
12455     } catch (std::exception& e) {
12456       {
12457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12458       };
12459     } catch (...) {
12460       {
12461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12462       };
12463     }
12464   }
12465   jresult = (void *)result;
12466   return jresult;
12467 }
12468
12469
12470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12471   void * jresult ;
12472   Dali::Radian arg1 ;
12473   Dali::Vector3 *arg2 = 0 ;
12474   Dali::Radian *argp1 ;
12475   Dali::AngleAxis *result = 0 ;
12476
12477   argp1 = (Dali::Radian *)jarg1;
12478   if (!argp1) {
12479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12480     return 0;
12481   }
12482   arg1 = *argp1;
12483   arg2 = (Dali::Vector3 *)jarg2;
12484   if (!arg2) {
12485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12486     return 0;
12487   }
12488   {
12489     try {
12490       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12491     } catch (std::out_of_range& e) {
12492       {
12493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12494       };
12495     } catch (std::exception& e) {
12496       {
12497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12498       };
12499     } catch (...) {
12500       {
12501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12502       };
12503     }
12504   }
12505   jresult = (void *)result;
12506   return jresult;
12507 }
12508
12509
12510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12511   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12512   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12513
12514   arg1 = (Dali::AngleAxis *)jarg1;
12515   arg2 = (Dali::Radian *)jarg2;
12516   if (arg1) (arg1)->angle = *arg2;
12517 }
12518
12519
12520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12521   void * jresult ;
12522   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12523   Dali::Radian *result = 0 ;
12524
12525   arg1 = (Dali::AngleAxis *)jarg1;
12526   result = (Dali::Radian *)& ((arg1)->angle);
12527   jresult = (void *)result;
12528   return jresult;
12529 }
12530
12531
12532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12533   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12534   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12535
12536   arg1 = (Dali::AngleAxis *)jarg1;
12537   arg2 = (Dali::Vector3 *)jarg2;
12538   if (arg1) (arg1)->axis = *arg2;
12539 }
12540
12541
12542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12543   void * jresult ;
12544   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12545   Dali::Vector3 *result = 0 ;
12546
12547   arg1 = (Dali::AngleAxis *)jarg1;
12548   result = (Dali::Vector3 *)& ((arg1)->axis);
12549   jresult = (void *)result;
12550   return jresult;
12551 }
12552
12553
12554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12555   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12556
12557   arg1 = (Dali::AngleAxis *)jarg1;
12558   {
12559     try {
12560       delete arg1;
12561     } catch (std::out_of_range& e) {
12562       {
12563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12564       };
12565     } catch (std::exception& e) {
12566       {
12567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12568       };
12569     } catch (...) {
12570       {
12571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12572       };
12573     }
12574   }
12575 }
12576
12577
12578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12579   unsigned int jresult ;
12580   Dali::AngleAxis *arg1 = 0 ;
12581   Dali::AngleAxis *arg2 = 0 ;
12582   bool result;
12583
12584   arg1 = (Dali::AngleAxis *)jarg1;
12585   if (!arg1) {
12586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12587     return 0;
12588   }
12589   arg2 = (Dali::AngleAxis *)jarg2;
12590   if (!arg2) {
12591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12592     return 0;
12593   }
12594   {
12595     try {
12596       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12597     } catch (std::out_of_range& e) {
12598       {
12599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12600       };
12601     } catch (std::exception& e) {
12602       {
12603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12604       };
12605     } catch (...) {
12606       {
12607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12608       };
12609     }
12610   }
12611   jresult = result;
12612   return jresult;
12613 }
12614
12615
12616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12617   unsigned int jresult ;
12618   unsigned int arg1 ;
12619   unsigned int result;
12620
12621   arg1 = (unsigned int)jarg1;
12622   {
12623     try {
12624       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12625     } catch (std::out_of_range& e) {
12626       {
12627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12628       };
12629     } catch (std::exception& e) {
12630       {
12631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12632       };
12633     } catch (...) {
12634       {
12635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12636       };
12637     }
12638   }
12639   jresult = result;
12640   return jresult;
12641 }
12642
12643
12644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12645   unsigned int jresult ;
12646   unsigned int arg1 ;
12647   bool result;
12648
12649   arg1 = (unsigned int)jarg1;
12650   {
12651     try {
12652       result = (bool)Dali::IsPowerOfTwo(arg1);
12653     } catch (std::out_of_range& e) {
12654       {
12655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12656       };
12657     } catch (std::exception& e) {
12658       {
12659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12660       };
12661     } catch (...) {
12662       {
12663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12664       };
12665     }
12666   }
12667   jresult = result;
12668   return jresult;
12669 }
12670
12671
12672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12673   float jresult ;
12674   float arg1 ;
12675   float arg2 ;
12676   float result;
12677
12678   arg1 = (float)jarg1;
12679   arg2 = (float)jarg2;
12680   {
12681     try {
12682       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12683     } catch (std::out_of_range& e) {
12684       {
12685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12686       };
12687     } catch (std::exception& e) {
12688       {
12689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12690       };
12691     } catch (...) {
12692       {
12693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12694       };
12695     }
12696   }
12697   jresult = result;
12698   return jresult;
12699 }
12700
12701
12702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12703   unsigned int jresult ;
12704   float arg1 ;
12705   bool result;
12706
12707   arg1 = (float)jarg1;
12708   {
12709     try {
12710       result = (bool)Dali::EqualsZero(arg1);
12711     } catch (std::out_of_range& e) {
12712       {
12713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12714       };
12715     } catch (std::exception& e) {
12716       {
12717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12718       };
12719     } catch (...) {
12720       {
12721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12722       };
12723     }
12724   }
12725   jresult = result;
12726   return jresult;
12727 }
12728
12729
12730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12731   unsigned int jresult ;
12732   float arg1 ;
12733   float arg2 ;
12734   bool result;
12735
12736   arg1 = (float)jarg1;
12737   arg2 = (float)jarg2;
12738   {
12739     try {
12740       result = (bool)Dali::Equals(arg1,arg2);
12741     } catch (std::out_of_range& e) {
12742       {
12743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12744       };
12745     } catch (std::exception& e) {
12746       {
12747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12748       };
12749     } catch (...) {
12750       {
12751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12752       };
12753     }
12754   }
12755   jresult = result;
12756   return jresult;
12757 }
12758
12759
12760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12761   unsigned int jresult ;
12762   float arg1 ;
12763   float arg2 ;
12764   float arg3 ;
12765   bool result;
12766
12767   arg1 = (float)jarg1;
12768   arg2 = (float)jarg2;
12769   arg3 = (float)jarg3;
12770   {
12771     try {
12772       result = (bool)Dali::Equals(arg1,arg2,arg3);
12773     } catch (std::out_of_range& e) {
12774       {
12775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12776       };
12777     } catch (std::exception& e) {
12778       {
12779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12780       };
12781     } catch (...) {
12782       {
12783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12784       };
12785     }
12786   }
12787   jresult = result;
12788   return jresult;
12789 }
12790
12791
12792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12793   float jresult ;
12794   float arg1 ;
12795   int arg2 ;
12796   float result;
12797
12798   arg1 = (float)jarg1;
12799   arg2 = (int)jarg2;
12800   {
12801     try {
12802       result = (float)Dali::Round(arg1,arg2);
12803     } catch (std::out_of_range& e) {
12804       {
12805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12806       };
12807     } catch (std::exception& e) {
12808       {
12809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12810       };
12811     } catch (...) {
12812       {
12813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12814       };
12815     }
12816   }
12817   jresult = result;
12818   return jresult;
12819 }
12820
12821
12822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12823   float jresult ;
12824   float arg1 ;
12825   float arg2 ;
12826   float arg3 ;
12827   float result;
12828
12829   arg1 = (float)jarg1;
12830   arg2 = (float)jarg2;
12831   arg3 = (float)jarg3;
12832   {
12833     try {
12834       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12835     } catch (std::out_of_range& e) {
12836       {
12837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12838       };
12839     } catch (std::exception& e) {
12840       {
12841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12842       };
12843     } catch (...) {
12844       {
12845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12846       };
12847     }
12848   }
12849   jresult = result;
12850   return jresult;
12851 }
12852
12853
12854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12855   float jresult ;
12856   float arg1 ;
12857   float arg2 ;
12858   float arg3 ;
12859   float arg4 ;
12860   float result;
12861
12862   arg1 = (float)jarg1;
12863   arg2 = (float)jarg2;
12864   arg3 = (float)jarg3;
12865   arg4 = (float)jarg4;
12866   {
12867     try {
12868       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12869     } catch (std::out_of_range& e) {
12870       {
12871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12872       };
12873     } catch (std::exception& e) {
12874       {
12875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12876       };
12877     } catch (...) {
12878       {
12879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12880       };
12881     }
12882   }
12883   jresult = result;
12884   return jresult;
12885 }
12886
12887
12888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12889   int jresult ;
12890   int result;
12891
12892   result = (int)(int)Dali::Property::INVALID_INDEX;
12893   jresult = result;
12894   return jresult;
12895 }
12896
12897
12898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12899   int jresult ;
12900   int result;
12901
12902   result = (int)(int)Dali::Property::INVALID_KEY;
12903   jresult = result;
12904   return jresult;
12905 }
12906
12907
12908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12909   int jresult ;
12910   int result;
12911
12912   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12913   jresult = result;
12914   return jresult;
12915 }
12916
12917
12918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12919   void * jresult ;
12920   Dali::Handle *arg1 = 0 ;
12921   Dali::Property::Index arg2 ;
12922   Dali::Property *result = 0 ;
12923
12924   arg1 = (Dali::Handle *)jarg1;
12925   if (!arg1) {
12926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12927     return 0;
12928   }
12929   arg2 = (Dali::Property::Index)jarg2;
12930   {
12931     try {
12932       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12933     } catch (std::out_of_range& e) {
12934       {
12935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12936       };
12937     } catch (std::exception& e) {
12938       {
12939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12940       };
12941     } catch (...) {
12942       {
12943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12944       };
12945     }
12946   }
12947   jresult = (void *)result;
12948   return jresult;
12949 }
12950
12951
12952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12953   void * jresult ;
12954   Dali::Handle *arg1 = 0 ;
12955   Dali::Property::Index arg2 ;
12956   int arg3 ;
12957   Dali::Property *result = 0 ;
12958
12959   arg1 = (Dali::Handle *)jarg1;
12960   if (!arg1) {
12961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12962     return 0;
12963   }
12964   arg2 = (Dali::Property::Index)jarg2;
12965   arg3 = (int)jarg3;
12966   {
12967     try {
12968       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12969     } catch (std::out_of_range& e) {
12970       {
12971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12972       };
12973     } catch (std::exception& e) {
12974       {
12975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12976       };
12977     } catch (...) {
12978       {
12979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12980       };
12981     }
12982   }
12983   jresult = (void *)result;
12984   return jresult;
12985 }
12986
12987
12988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
12989   void * jresult ;
12990   Dali::Handle *arg1 = 0 ;
12991   std::string *arg2 = 0 ;
12992   Dali::Property *result = 0 ;
12993
12994   arg1 = (Dali::Handle *)jarg1;
12995   if (!arg1) {
12996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12997     return 0;
12998   }
12999   if (!jarg2) {
13000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13001     return 0;
13002   }
13003   std::string arg2_str(jarg2);
13004   arg2 = &arg2_str;
13005   {
13006     try {
13007       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13008     } catch (std::out_of_range& e) {
13009       {
13010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13011       };
13012     } catch (std::exception& e) {
13013       {
13014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13015       };
13016     } catch (...) {
13017       {
13018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13019       };
13020     }
13021   }
13022   jresult = (void *)result;
13023
13024   //argout typemap for const std::string&
13025
13026   return jresult;
13027 }
13028
13029
13030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13031   void * jresult ;
13032   Dali::Handle *arg1 = 0 ;
13033   std::string *arg2 = 0 ;
13034   int arg3 ;
13035   Dali::Property *result = 0 ;
13036
13037   arg1 = (Dali::Handle *)jarg1;
13038   if (!arg1) {
13039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13040     return 0;
13041   }
13042   if (!jarg2) {
13043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13044     return 0;
13045   }
13046   std::string arg2_str(jarg2);
13047   arg2 = &arg2_str;
13048   arg3 = (int)jarg3;
13049   {
13050     try {
13051       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13052     } catch (std::out_of_range& e) {
13053       {
13054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13055       };
13056     } catch (std::exception& e) {
13057       {
13058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13059       };
13060     } catch (...) {
13061       {
13062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13063       };
13064     }
13065   }
13066   jresult = (void *)result;
13067
13068   //argout typemap for const std::string&
13069
13070   return jresult;
13071 }
13072
13073
13074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13075   Dali::Property *arg1 = (Dali::Property *) 0 ;
13076
13077   arg1 = (Dali::Property *)jarg1;
13078   {
13079     try {
13080       delete arg1;
13081     } catch (std::out_of_range& e) {
13082       {
13083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13084       };
13085     } catch (std::exception& e) {
13086       {
13087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13088       };
13089     } catch (...) {
13090       {
13091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13092       };
13093     }
13094   }
13095 }
13096
13097
13098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13099   Dali::Property *arg1 = (Dali::Property *) 0 ;
13100   Dali::Handle *arg2 = 0 ;
13101
13102   arg1 = (Dali::Property *)jarg1;
13103   arg2 = (Dali::Handle *)jarg2;
13104   if (!arg2) {
13105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13106     return ;
13107   }
13108   if (arg1) (arg1)->object = *arg2;
13109 }
13110
13111
13112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13113   void * jresult ;
13114   Dali::Property *arg1 = (Dali::Property *) 0 ;
13115   Dali::Handle *result = 0 ;
13116
13117   arg1 = (Dali::Property *)jarg1;
13118   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13119   jresult = (void *)result;
13120   return jresult;
13121 }
13122
13123
13124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13125   Dali::Property *arg1 = (Dali::Property *) 0 ;
13126   Dali::Property::Index arg2 ;
13127
13128   arg1 = (Dali::Property *)jarg1;
13129   arg2 = (Dali::Property::Index)jarg2;
13130   if (arg1) (arg1)->propertyIndex = arg2;
13131 }
13132
13133
13134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13135   int jresult ;
13136   Dali::Property *arg1 = (Dali::Property *) 0 ;
13137   Dali::Property::Index result;
13138
13139   arg1 = (Dali::Property *)jarg1;
13140   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13141   jresult = result;
13142   return jresult;
13143 }
13144
13145
13146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13147   Dali::Property *arg1 = (Dali::Property *) 0 ;
13148   int arg2 ;
13149
13150   arg1 = (Dali::Property *)jarg1;
13151   arg2 = (int)jarg2;
13152   if (arg1) (arg1)->componentIndex = arg2;
13153 }
13154
13155
13156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13157   int jresult ;
13158   Dali::Property *arg1 = (Dali::Property *) 0 ;
13159   int result;
13160
13161   arg1 = (Dali::Property *)jarg1;
13162   result = (int) ((arg1)->componentIndex);
13163   jresult = result;
13164   return jresult;
13165 }
13166
13167
13168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13169   void * jresult ;
13170   Dali::Property::Array *result = 0 ;
13171
13172   {
13173     try {
13174       result = (Dali::Property::Array *)new Dali::Property::Array();
13175     } catch (std::out_of_range& e) {
13176       {
13177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13178       };
13179     } catch (std::exception& e) {
13180       {
13181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13182       };
13183     } catch (...) {
13184       {
13185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13186       };
13187     }
13188   }
13189   jresult = (void *)result;
13190   return jresult;
13191 }
13192
13193
13194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13195   void * jresult ;
13196   Dali::Property::Array *arg1 = 0 ;
13197   Dali::Property::Array *result = 0 ;
13198
13199   arg1 = (Dali::Property::Array *)jarg1;
13200   if (!arg1) {
13201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13202     return 0;
13203   }
13204   {
13205     try {
13206       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13207     } catch (std::out_of_range& e) {
13208       {
13209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13210       };
13211     } catch (std::exception& e) {
13212       {
13213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13214       };
13215     } catch (...) {
13216       {
13217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13218       };
13219     }
13220   }
13221   jresult = (void *)result;
13222   return jresult;
13223 }
13224
13225
13226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13227   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13228
13229   arg1 = (Dali::Property::Array *)jarg1;
13230   {
13231     try {
13232       delete arg1;
13233     } catch (std::out_of_range& e) {
13234       {
13235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13236       };
13237     } catch (std::exception& e) {
13238       {
13239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13240       };
13241     } catch (...) {
13242       {
13243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13244       };
13245     }
13246   }
13247 }
13248
13249
13250 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13251   unsigned long jresult ;
13252   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13253   Dali::Property::Array::SizeType result;
13254
13255   arg1 = (Dali::Property::Array *)jarg1;
13256   {
13257     try {
13258       result = ((Dali::Property::Array const *)arg1)->Size();
13259     } catch (std::out_of_range& e) {
13260       {
13261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13262       };
13263     } catch (std::exception& e) {
13264       {
13265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13266       };
13267     } catch (...) {
13268       {
13269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13270       };
13271     }
13272   }
13273   jresult = (unsigned long)result;
13274   return jresult;
13275 }
13276
13277
13278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13279   unsigned long jresult ;
13280   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13281   Dali::Property::Array::SizeType result;
13282
13283   arg1 = (Dali::Property::Array *)jarg1;
13284   {
13285     try {
13286       result = ((Dali::Property::Array const *)arg1)->Count();
13287     } catch (std::out_of_range& e) {
13288       {
13289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13290       };
13291     } catch (std::exception& e) {
13292       {
13293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13294       };
13295     } catch (...) {
13296       {
13297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13298       };
13299     }
13300   }
13301   jresult = (unsigned long)result;
13302   return jresult;
13303 }
13304
13305
13306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13307   unsigned int jresult ;
13308   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13309   bool result;
13310
13311   arg1 = (Dali::Property::Array *)jarg1;
13312   {
13313     try {
13314       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13315     } catch (std::out_of_range& e) {
13316       {
13317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13318       };
13319     } catch (std::exception& e) {
13320       {
13321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13322       };
13323     } catch (...) {
13324       {
13325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13326       };
13327     }
13328   }
13329   jresult = result;
13330   return jresult;
13331 }
13332
13333
13334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13335   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13336
13337   arg1 = (Dali::Property::Array *)jarg1;
13338   {
13339     try {
13340       (arg1)->Clear();
13341     } catch (std::out_of_range& e) {
13342       {
13343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13344       };
13345     } catch (std::exception& e) {
13346       {
13347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13348       };
13349     } catch (...) {
13350       {
13351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13352       };
13353     }
13354   }
13355 }
13356
13357
13358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13359   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13360   Dali::Property::Array::SizeType arg2 ;
13361
13362   arg1 = (Dali::Property::Array *)jarg1;
13363   arg2 = (Dali::Property::Array::SizeType)jarg2;
13364   {
13365     try {
13366       (arg1)->Reserve(arg2);
13367     } catch (std::out_of_range& e) {
13368       {
13369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13370       };
13371     } catch (std::exception& e) {
13372       {
13373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13374       };
13375     } catch (...) {
13376       {
13377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13378       };
13379     }
13380   }
13381 }
13382
13383
13384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13385   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13386   Dali::Property::Array::SizeType arg2 ;
13387
13388   arg1 = (Dali::Property::Array *)jarg1;
13389   arg2 = (Dali::Property::Array::SizeType)jarg2;
13390   {
13391     try {
13392       (arg1)->Resize(arg2);
13393     } catch (std::out_of_range& e) {
13394       {
13395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13396       };
13397     } catch (std::exception& e) {
13398       {
13399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13400       };
13401     } catch (...) {
13402       {
13403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13404       };
13405     }
13406   }
13407 }
13408
13409
13410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13411   unsigned long jresult ;
13412   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13413   Dali::Property::Array::SizeType result;
13414
13415   arg1 = (Dali::Property::Array *)jarg1;
13416   {
13417     try {
13418       result = (arg1)->Capacity();
13419     } catch (std::out_of_range& e) {
13420       {
13421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13422       };
13423     } catch (std::exception& e) {
13424       {
13425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13426       };
13427     } catch (...) {
13428       {
13429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13430       };
13431     }
13432   }
13433   jresult = (unsigned long)result;
13434   return jresult;
13435 }
13436
13437
13438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13439   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13440   Dali::Property::Value *arg2 = 0 ;
13441
13442   arg1 = (Dali::Property::Array *)jarg1;
13443   arg2 = (Dali::Property::Value *)jarg2;
13444   if (!arg2) {
13445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13446     return ;
13447   }
13448   {
13449     try {
13450       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13451     } catch (std::out_of_range& e) {
13452       {
13453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13454       };
13455     } catch (std::exception& e) {
13456       {
13457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13458       };
13459     } catch (...) {
13460       {
13461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13462       };
13463     }
13464   }
13465 }
13466
13467
13468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13469   void * jresult ;
13470   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13471   Dali::Property::Value *arg2 = 0 ;
13472   Dali::Property::Array *result = 0 ;
13473
13474   arg1 = (Dali::Property::Array *)jarg1;
13475   arg2 = (Dali::Property::Value *)jarg2;
13476   if (!arg2) {
13477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13478     return 0;
13479   }
13480   {
13481     try {
13482       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13483     } catch (std::out_of_range& e) {
13484       {
13485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13486       };
13487     } catch (std::exception& e) {
13488       {
13489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13490       };
13491     } catch (...) {
13492       {
13493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13494       };
13495     }
13496   }
13497   jresult = (void *)result;
13498   return jresult;
13499 }
13500
13501
13502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13503   void * jresult ;
13504   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13505   Dali::Property::Array::SizeType arg2 ;
13506   Dali::Property::Value *result = 0 ;
13507
13508   arg1 = (Dali::Property::Array *)jarg1;
13509   arg2 = (Dali::Property::Array::SizeType)jarg2;
13510   {
13511     try {
13512       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13513     } catch (std::out_of_range& e) {
13514       {
13515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13516       };
13517     } catch (std::exception& e) {
13518       {
13519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13520       };
13521     } catch (...) {
13522       {
13523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13524       };
13525     }
13526   }
13527   jresult = (void *)result;
13528   return jresult;
13529 }
13530
13531
13532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13533   void * jresult ;
13534   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13535   Dali::Property::Array::SizeType arg2 ;
13536   Dali::Property::Value *result = 0 ;
13537
13538   arg1 = (Dali::Property::Array *)jarg1;
13539   arg2 = (Dali::Property::Array::SizeType)jarg2;
13540   {
13541     try {
13542       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13543     } catch (std::out_of_range& e) {
13544       {
13545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13546       };
13547     } catch (std::exception& e) {
13548       {
13549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13550       };
13551     } catch (...) {
13552       {
13553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13554       };
13555     }
13556   }
13557   jresult = (void *)result;
13558   return jresult;
13559 }
13560
13561
13562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13563   void * jresult ;
13564   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13565   Dali::Property::Array *arg2 = 0 ;
13566   Dali::Property::Array *result = 0 ;
13567
13568   arg1 = (Dali::Property::Array *)jarg1;
13569   arg2 = (Dali::Property::Array *)jarg2;
13570   if (!arg2) {
13571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13572     return 0;
13573   }
13574   {
13575     try {
13576       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13577     } catch (std::out_of_range& e) {
13578       {
13579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13580       };
13581     } catch (std::exception& e) {
13582       {
13583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13584       };
13585     } catch (...) {
13586       {
13587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13588       };
13589     }
13590   }
13591   jresult = (void *)result;
13592   return jresult;
13593 }
13594
13595
13596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13597   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13598   enum Dali::Property::Key::Type arg2 ;
13599
13600   arg1 = (Dali::Property::Key *)jarg1;
13601   arg2 = (enum Dali::Property::Key::Type)jarg2;
13602   if (arg1) (arg1)->type = arg2;
13603 }
13604
13605
13606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13607   int jresult ;
13608   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13609   enum Dali::Property::Key::Type result;
13610
13611   arg1 = (Dali::Property::Key *)jarg1;
13612   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13613   jresult = (int)result;
13614   return jresult;
13615 }
13616
13617
13618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13619   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13620   Dali::Property::Index arg2 ;
13621
13622   arg1 = (Dali::Property::Key *)jarg1;
13623   arg2 = (Dali::Property::Index)jarg2;
13624   if (arg1) (arg1)->indexKey = arg2;
13625 }
13626
13627
13628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13629   int jresult ;
13630   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13631   Dali::Property::Index result;
13632
13633   arg1 = (Dali::Property::Key *)jarg1;
13634   result = (Dali::Property::Index) ((arg1)->indexKey);
13635   jresult = result;
13636   return jresult;
13637 }
13638
13639
13640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13641   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13642   std::string *arg2 = 0 ;
13643
13644   arg1 = (Dali::Property::Key *)jarg1;
13645   if (!jarg2) {
13646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13647     return ;
13648   }
13649   std::string arg2_str(jarg2);
13650   arg2 = &arg2_str;
13651   if (arg1) (arg1)->stringKey = *arg2;
13652
13653   //argout typemap for const std::string&
13654
13655 }
13656
13657
13658 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13659   char * jresult ;
13660   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13661   std::string *result = 0 ;
13662
13663   arg1 = (Dali::Property::Key *)jarg1;
13664   result = (std::string *) & ((arg1)->stringKey);
13665   jresult = SWIG_csharp_string_callback(result->c_str());
13666   return jresult;
13667 }
13668
13669
13670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13671   void * jresult ;
13672   std::string *arg1 = 0 ;
13673   Dali::Property::Key *result = 0 ;
13674
13675   if (!jarg1) {
13676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13677     return 0;
13678   }
13679   std::string arg1_str(jarg1);
13680   arg1 = &arg1_str;
13681   {
13682     try {
13683       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13684     } catch (std::out_of_range& e) {
13685       {
13686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13687       };
13688     } catch (std::exception& e) {
13689       {
13690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13691       };
13692     } catch (...) {
13693       {
13694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13695       };
13696     }
13697   }
13698   jresult = (void *)result;
13699
13700   //argout typemap for const std::string&
13701
13702   return jresult;
13703 }
13704
13705
13706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13707   void * jresult ;
13708   Dali::Property::Index arg1 ;
13709   Dali::Property::Key *result = 0 ;
13710
13711   arg1 = (Dali::Property::Index)jarg1;
13712   {
13713     try {
13714       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13715     } catch (std::out_of_range& e) {
13716       {
13717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13718       };
13719     } catch (std::exception& e) {
13720       {
13721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13722       };
13723     } catch (...) {
13724       {
13725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13726       };
13727     }
13728   }
13729   jresult = (void *)result;
13730   return jresult;
13731 }
13732
13733
13734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13735   unsigned int jresult ;
13736   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13737   std::string *arg2 = 0 ;
13738   bool result;
13739
13740   arg1 = (Dali::Property::Key *)jarg1;
13741   if (!jarg2) {
13742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13743     return 0;
13744   }
13745   std::string arg2_str(jarg2);
13746   arg2 = &arg2_str;
13747   {
13748     try {
13749       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13750     } catch (std::out_of_range& e) {
13751       {
13752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13753       };
13754     } catch (std::exception& e) {
13755       {
13756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13757       };
13758     } catch (...) {
13759       {
13760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13761       };
13762     }
13763   }
13764   jresult = result;
13765
13766   //argout typemap for const std::string&
13767
13768   return jresult;
13769 }
13770
13771
13772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13773   unsigned int jresult ;
13774   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13775   Dali::Property::Index arg2 ;
13776   bool result;
13777
13778   arg1 = (Dali::Property::Key *)jarg1;
13779   arg2 = (Dali::Property::Index)jarg2;
13780   {
13781     try {
13782       result = (bool)(arg1)->operator ==(arg2);
13783     } catch (std::out_of_range& e) {
13784       {
13785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13786       };
13787     } catch (std::exception& e) {
13788       {
13789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13790       };
13791     } catch (...) {
13792       {
13793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13794       };
13795     }
13796   }
13797   jresult = result;
13798   return jresult;
13799 }
13800
13801
13802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13803   unsigned int jresult ;
13804   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13805   Dali::Property::Key *arg2 = 0 ;
13806   bool result;
13807
13808   arg1 = (Dali::Property::Key *)jarg1;
13809   arg2 = (Dali::Property::Key *)jarg2;
13810   if (!arg2) {
13811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13812     return 0;
13813   }
13814   {
13815     try {
13816       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13817     } catch (std::out_of_range& e) {
13818       {
13819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (std::exception& e) {
13822       {
13823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (...) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13828       };
13829     }
13830   }
13831   jresult = result;
13832   return jresult;
13833 }
13834
13835
13836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13837   unsigned int jresult ;
13838   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13839   std::string *arg2 = 0 ;
13840   bool result;
13841
13842   arg1 = (Dali::Property::Key *)jarg1;
13843   if (!jarg2) {
13844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13845     return 0;
13846   }
13847   std::string arg2_str(jarg2);
13848   arg2 = &arg2_str;
13849   {
13850     try {
13851       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13852     } catch (std::out_of_range& e) {
13853       {
13854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13855       };
13856     } catch (std::exception& e) {
13857       {
13858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13859       };
13860     } catch (...) {
13861       {
13862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13863       };
13864     }
13865   }
13866   jresult = result;
13867
13868   //argout typemap for const std::string&
13869
13870   return jresult;
13871 }
13872
13873
13874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13875   unsigned int jresult ;
13876   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13877   Dali::Property::Index arg2 ;
13878   bool result;
13879
13880   arg1 = (Dali::Property::Key *)jarg1;
13881   arg2 = (Dali::Property::Index)jarg2;
13882   {
13883     try {
13884       result = (bool)(arg1)->operator !=(arg2);
13885     } catch (std::out_of_range& e) {
13886       {
13887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13888       };
13889     } catch (std::exception& e) {
13890       {
13891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13892       };
13893     } catch (...) {
13894       {
13895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13896       };
13897     }
13898   }
13899   jresult = result;
13900   return jresult;
13901 }
13902
13903
13904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13905   unsigned int jresult ;
13906   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13907   Dali::Property::Key *arg2 = 0 ;
13908   bool result;
13909
13910   arg1 = (Dali::Property::Key *)jarg1;
13911   arg2 = (Dali::Property::Key *)jarg2;
13912   if (!arg2) {
13913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13914     return 0;
13915   }
13916   {
13917     try {
13918       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13919     } catch (std::out_of_range& e) {
13920       {
13921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13922       };
13923     } catch (std::exception& e) {
13924       {
13925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13926       };
13927     } catch (...) {
13928       {
13929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13930       };
13931     }
13932   }
13933   jresult = result;
13934   return jresult;
13935 }
13936
13937
13938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13939   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13940
13941   arg1 = (Dali::Property::Key *)jarg1;
13942   {
13943     try {
13944       delete arg1;
13945     } catch (std::out_of_range& e) {
13946       {
13947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13948       };
13949     } catch (std::exception& e) {
13950       {
13951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13952       };
13953     } catch (...) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13956       };
13957     }
13958   }
13959 }
13960
13961
13962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13963   void * jresult ;
13964   Dali::Property::Map *result = 0 ;
13965
13966   {
13967     try {
13968       result = (Dali::Property::Map *)new Dali::Property::Map();
13969     } catch (std::out_of_range& e) {
13970       {
13971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13972       };
13973     } catch (std::exception& e) {
13974       {
13975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13976       };
13977     } catch (...) {
13978       {
13979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13980       };
13981     }
13982   }
13983   jresult = (void *)result;
13984   return jresult;
13985 }
13986
13987
13988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
13989   void * jresult ;
13990   Dali::Property::Map *arg1 = 0 ;
13991   Dali::Property::Map *result = 0 ;
13992
13993   arg1 = (Dali::Property::Map *)jarg1;
13994   if (!arg1) {
13995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13996     return 0;
13997   }
13998   {
13999     try {
14000       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14001     } catch (std::out_of_range& e) {
14002       {
14003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14004       };
14005     } catch (std::exception& e) {
14006       {
14007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14008       };
14009     } catch (...) {
14010       {
14011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14012       };
14013     }
14014   }
14015   jresult = (void *)result;
14016   return jresult;
14017 }
14018
14019
14020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14021   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14022
14023   arg1 = (Dali::Property::Map *)jarg1;
14024   {
14025     try {
14026       delete arg1;
14027     } catch (std::out_of_range& e) {
14028       {
14029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14030       };
14031     } catch (std::exception& e) {
14032       {
14033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14034       };
14035     } catch (...) {
14036       {
14037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14038       };
14039     }
14040   }
14041 }
14042
14043
14044 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14045   unsigned long jresult ;
14046   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14047   Dali::Property::Map::SizeType result;
14048
14049   arg1 = (Dali::Property::Map *)jarg1;
14050   {
14051     try {
14052       result = ((Dali::Property::Map const *)arg1)->Count();
14053     } catch (std::out_of_range& e) {
14054       {
14055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14056       };
14057     } catch (std::exception& e) {
14058       {
14059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14060       };
14061     } catch (...) {
14062       {
14063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14064       };
14065     }
14066   }
14067   jresult = (unsigned long)result;
14068   return jresult;
14069 }
14070
14071
14072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14073   unsigned int jresult ;
14074   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14075   bool result;
14076
14077   arg1 = (Dali::Property::Map *)jarg1;
14078   {
14079     try {
14080       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14081     } catch (std::out_of_range& e) {
14082       {
14083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14084       };
14085     } catch (std::exception& e) {
14086       {
14087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14088       };
14089     } catch (...) {
14090       {
14091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14092       };
14093     }
14094   }
14095   jresult = result;
14096   return jresult;
14097 }
14098
14099
14100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14101   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14102   char *arg2 = (char *) 0 ;
14103   Dali::Property::Value *arg3 = 0 ;
14104
14105   arg1 = (Dali::Property::Map *)jarg1;
14106   arg2 = (char *)jarg2;
14107   arg3 = (Dali::Property::Value *)jarg3;
14108   if (!arg3) {
14109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14110     return ;
14111   }
14112   {
14113     try {
14114       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14115     } catch (std::out_of_range& e) {
14116       {
14117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14118       };
14119     } catch (std::exception& e) {
14120       {
14121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14122       };
14123     } catch (...) {
14124       {
14125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14126       };
14127     }
14128   }
14129 }
14130
14131
14132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14133   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14134   Dali::Property::Index arg2 ;
14135   Dali::Property::Value *arg3 = 0 ;
14136
14137   arg1 = (Dali::Property::Map *)jarg1;
14138   arg2 = (Dali::Property::Index)jarg2;
14139   arg3 = (Dali::Property::Value *)jarg3;
14140   if (!arg3) {
14141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14142     return ;
14143   }
14144   {
14145     try {
14146       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14147     } catch (std::out_of_range& e) {
14148       {
14149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14150       };
14151     } catch (std::exception& e) {
14152       {
14153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14154       };
14155     } catch (...) {
14156       {
14157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14158       };
14159     }
14160   }
14161 }
14162
14163
14164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14165   void * jresult ;
14166   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14167   char *arg2 = (char *) 0 ;
14168   Dali::Property::Value *arg3 = 0 ;
14169   Dali::Property::Map *result = 0 ;
14170
14171   arg1 = (Dali::Property::Map *)jarg1;
14172   arg2 = (char *)jarg2;
14173   arg3 = (Dali::Property::Value *)jarg3;
14174   if (!arg3) {
14175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14176     return 0;
14177   }
14178   {
14179     try {
14180       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14181     } catch (std::out_of_range& e) {
14182       {
14183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14184       };
14185     } catch (std::exception& e) {
14186       {
14187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14188       };
14189     } catch (...) {
14190       {
14191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14192       };
14193     }
14194   }
14195   jresult = (void *)result;
14196   return jresult;
14197 }
14198
14199
14200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14201   void * jresult ;
14202   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14203   Dali::Property::Index arg2 ;
14204   Dali::Property::Value *arg3 = 0 ;
14205   Dali::Property::Map *result = 0 ;
14206
14207   arg1 = (Dali::Property::Map *)jarg1;
14208   arg2 = (Dali::Property::Index)jarg2;
14209   arg3 = (Dali::Property::Value *)jarg3;
14210   if (!arg3) {
14211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14212     return 0;
14213   }
14214   {
14215     try {
14216       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14217     } catch (std::out_of_range& e) {
14218       {
14219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14220       };
14221     } catch (std::exception& e) {
14222       {
14223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14224       };
14225     } catch (...) {
14226       {
14227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14228       };
14229     }
14230   }
14231   jresult = (void *)result;
14232   return jresult;
14233 }
14234
14235
14236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14237   void * jresult ;
14238   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14239   Dali::Property::Map::SizeType arg2 ;
14240   Dali::Property::Value *result = 0 ;
14241
14242   arg1 = (Dali::Property::Map *)jarg1;
14243   arg2 = (Dali::Property::Map::SizeType)jarg2;
14244   {
14245     try {
14246       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14247     } catch (std::out_of_range& e) {
14248       {
14249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14250       };
14251     } catch (std::exception& e) {
14252       {
14253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14254       };
14255     } catch (...) {
14256       {
14257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14258       };
14259     }
14260   }
14261   jresult = (void *)result;
14262   return jresult;
14263 }
14264
14265
14266 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14267   char * jresult ;
14268   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14269   Dali::Property::Map::SizeType arg2 ;
14270   std::string *result = 0 ;
14271
14272   arg1 = (Dali::Property::Map *)jarg1;
14273   arg2 = (Dali::Property::Map::SizeType)jarg2;
14274   {
14275     try {
14276       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14277     } catch (std::out_of_range& e) {
14278       {
14279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14280       };
14281     } catch (std::exception& e) {
14282       {
14283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (...) {
14286       {
14287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14288       };
14289     }
14290   }
14291   jresult = SWIG_csharp_string_callback(result->c_str());
14292   return jresult;
14293 }
14294
14295
14296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14297   void * jresult ;
14298   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14299   Dali::Property::Map::SizeType arg2 ;
14300   SwigValueWrapper< Dali::Property::Key > result;
14301
14302   arg1 = (Dali::Property::Map *)jarg1;
14303   arg2 = (Dali::Property::Map::SizeType)jarg2;
14304   {
14305     try {
14306       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14307     } catch (std::out_of_range& e) {
14308       {
14309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14310       };
14311     } catch (std::exception& e) {
14312       {
14313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14314       };
14315     } catch (...) {
14316       {
14317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14318       };
14319     }
14320   }
14321   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14322   return jresult;
14323 }
14324
14325
14326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14327   void * jresult ;
14328   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14329   Dali::Property::Map::SizeType arg2 ;
14330   StringValuePair *result = 0 ;
14331
14332   arg1 = (Dali::Property::Map *)jarg1;
14333   arg2 = (Dali::Property::Map::SizeType)jarg2;
14334   {
14335     try {
14336       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14337     } catch (std::out_of_range& e) {
14338       {
14339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14340       };
14341     } catch (std::exception& e) {
14342       {
14343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14344       };
14345     } catch (...) {
14346       {
14347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14348       };
14349     }
14350   }
14351   jresult = (void *)result;
14352   return jresult;
14353 }
14354
14355
14356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14357   void * jresult ;
14358   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14359   char *arg2 = (char *) 0 ;
14360   Dali::Property::Value *result = 0 ;
14361
14362   arg1 = (Dali::Property::Map *)jarg1;
14363   arg2 = (char *)jarg2;
14364   {
14365     try {
14366       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14367     } catch (std::out_of_range& e) {
14368       {
14369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14370       };
14371     } catch (std::exception& e) {
14372       {
14373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14374       };
14375     } catch (...) {
14376       {
14377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14378       };
14379     }
14380   }
14381   jresult = (void *)result;
14382   return jresult;
14383 }
14384
14385
14386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14387   void * jresult ;
14388   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14389   Dali::Property::Index arg2 ;
14390   Dali::Property::Value *result = 0 ;
14391
14392   arg1 = (Dali::Property::Map *)jarg1;
14393   arg2 = (Dali::Property::Index)jarg2;
14394   {
14395     try {
14396       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14397     } catch (std::out_of_range& e) {
14398       {
14399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14400       };
14401     } catch (std::exception& e) {
14402       {
14403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14404       };
14405     } catch (...) {
14406       {
14407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14408       };
14409     }
14410   }
14411   jresult = (void *)result;
14412   return jresult;
14413 }
14414
14415
14416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14417   void * jresult ;
14418   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14419   Dali::Property::Index arg2 ;
14420   std::string *arg3 = 0 ;
14421   Dali::Property::Value *result = 0 ;
14422
14423   arg1 = (Dali::Property::Map *)jarg1;
14424   arg2 = (Dali::Property::Index)jarg2;
14425   if (!jarg3) {
14426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14427     return 0;
14428   }
14429   std::string arg3_str(jarg3);
14430   arg3 = &arg3_str;
14431   {
14432     try {
14433       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14434     } catch (std::out_of_range& e) {
14435       {
14436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14437       };
14438     } catch (std::exception& e) {
14439       {
14440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14441       };
14442     } catch (...) {
14443       {
14444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14445       };
14446     }
14447   }
14448   jresult = (void *)result;
14449
14450   //argout typemap for const std::string&
14451
14452   return jresult;
14453 }
14454
14455
14456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14457   void * jresult ;
14458   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14459   std::string *arg2 = 0 ;
14460   Dali::Property::Type arg3 ;
14461   Dali::Property::Value *result = 0 ;
14462
14463   arg1 = (Dali::Property::Map *)jarg1;
14464   if (!jarg2) {
14465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14466     return 0;
14467   }
14468   std::string arg2_str(jarg2);
14469   arg2 = &arg2_str;
14470   arg3 = (Dali::Property::Type)jarg3;
14471   {
14472     try {
14473       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14474     } catch (std::out_of_range& e) {
14475       {
14476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14477       };
14478     } catch (std::exception& e) {
14479       {
14480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14481       };
14482     } catch (...) {
14483       {
14484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14485       };
14486     }
14487   }
14488   jresult = (void *)result;
14489
14490   //argout typemap for const std::string&
14491
14492   return jresult;
14493 }
14494
14495
14496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14497   void * jresult ;
14498   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14499   Dali::Property::Index arg2 ;
14500   Dali::Property::Type arg3 ;
14501   Dali::Property::Value *result = 0 ;
14502
14503   arg1 = (Dali::Property::Map *)jarg1;
14504   arg2 = (Dali::Property::Index)jarg2;
14505   arg3 = (Dali::Property::Type)jarg3;
14506   {
14507     try {
14508       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14509     } catch (std::out_of_range& e) {
14510       {
14511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14512       };
14513     } catch (std::exception& e) {
14514       {
14515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14516       };
14517     } catch (...) {
14518       {
14519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14520       };
14521     }
14522   }
14523   jresult = (void *)result;
14524   return jresult;
14525 }
14526
14527
14528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14529   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14530
14531   arg1 = (Dali::Property::Map *)jarg1;
14532   {
14533     try {
14534       (arg1)->Clear();
14535     } catch (std::out_of_range& e) {
14536       {
14537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14538       };
14539     } catch (std::exception& e) {
14540       {
14541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14542       };
14543     } catch (...) {
14544       {
14545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14546       };
14547     }
14548   }
14549 }
14550
14551
14552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14553   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14554   Dali::Property::Map *arg2 = 0 ;
14555
14556   arg1 = (Dali::Property::Map *)jarg1;
14557   arg2 = (Dali::Property::Map *)jarg2;
14558   if (!arg2) {
14559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14560     return ;
14561   }
14562   {
14563     try {
14564       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14565     } catch (std::out_of_range& e) {
14566       {
14567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14568       };
14569     } catch (std::exception& e) {
14570       {
14571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14572       };
14573     } catch (...) {
14574       {
14575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14576       };
14577     }
14578   }
14579 }
14580
14581
14582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14583   void * jresult ;
14584   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14585   std::string *arg2 = 0 ;
14586   Dali::Property::Value *result = 0 ;
14587
14588   arg1 = (Dali::Property::Map *)jarg1;
14589   if (!jarg2) {
14590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14591     return 0;
14592   }
14593   std::string arg2_str(jarg2);
14594   arg2 = &arg2_str;
14595   {
14596     try {
14597       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14598     } catch (std::out_of_range& e) {
14599       {
14600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14601       };
14602     } catch (std::exception& e) {
14603       {
14604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14605       };
14606     } catch (...) {
14607       {
14608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14609       };
14610     }
14611   }
14612   jresult = (void *)result;
14613
14614   //argout typemap for const std::string&
14615
14616   return jresult;
14617 }
14618
14619
14620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14621   void * jresult ;
14622   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14623   Dali::Property::Index arg2 ;
14624   Dali::Property::Value *result = 0 ;
14625
14626   arg1 = (Dali::Property::Map *)jarg1;
14627   arg2 = (Dali::Property::Index)jarg2;
14628   {
14629     try {
14630       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14631     } catch (std::out_of_range& e) {
14632       {
14633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14634       };
14635     } catch (std::exception& e) {
14636       {
14637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14638       };
14639     } catch (...) {
14640       {
14641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14642       };
14643     }
14644   }
14645   jresult = (void *)result;
14646   return jresult;
14647 }
14648
14649
14650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14651   void * jresult ;
14652   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14653   Dali::Property::Map *arg2 = 0 ;
14654   Dali::Property::Map *result = 0 ;
14655
14656   arg1 = (Dali::Property::Map *)jarg1;
14657   arg2 = (Dali::Property::Map *)jarg2;
14658   if (!arg2) {
14659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14660     return 0;
14661   }
14662   {
14663     try {
14664       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14665     } catch (std::out_of_range& e) {
14666       {
14667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14668       };
14669     } catch (std::exception& e) {
14670       {
14671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14672       };
14673     } catch (...) {
14674       {
14675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14676       };
14677     }
14678   }
14679   jresult = (void *)result;
14680   return jresult;
14681 }
14682
14683
14684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14685   void * jresult ;
14686   Dali::Property::Value *result = 0 ;
14687
14688   {
14689     try {
14690       result = (Dali::Property::Value *)new Dali::Property::Value();
14691     } catch (std::out_of_range& e) {
14692       {
14693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14694       };
14695     } catch (std::exception& e) {
14696       {
14697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14698       };
14699     } catch (...) {
14700       {
14701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14702       };
14703     }
14704   }
14705   jresult = (void *)result;
14706   return jresult;
14707 }
14708
14709
14710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14711   void * jresult ;
14712   bool arg1 ;
14713   Dali::Property::Value *result = 0 ;
14714
14715   arg1 = jarg1 ? true : false;
14716   {
14717     try {
14718       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14719     } catch (std::out_of_range& e) {
14720       {
14721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14722       };
14723     } catch (std::exception& e) {
14724       {
14725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14726       };
14727     } catch (...) {
14728       {
14729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14730       };
14731     }
14732   }
14733   jresult = (void *)result;
14734   return jresult;
14735 }
14736
14737
14738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14739   void * jresult ;
14740   int arg1 ;
14741   Dali::Property::Value *result = 0 ;
14742
14743   arg1 = (int)jarg1;
14744   {
14745     try {
14746       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14747     } catch (std::out_of_range& e) {
14748       {
14749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14750       };
14751     } catch (std::exception& e) {
14752       {
14753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14754       };
14755     } catch (...) {
14756       {
14757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14758       };
14759     }
14760   }
14761   jresult = (void *)result;
14762   return jresult;
14763 }
14764
14765
14766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14767   void * jresult ;
14768   float arg1 ;
14769   Dali::Property::Value *result = 0 ;
14770
14771   arg1 = (float)jarg1;
14772   {
14773     try {
14774       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14775     } catch (std::out_of_range& e) {
14776       {
14777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14778       };
14779     } catch (std::exception& e) {
14780       {
14781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14782       };
14783     } catch (...) {
14784       {
14785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14786       };
14787     }
14788   }
14789   jresult = (void *)result;
14790   return jresult;
14791 }
14792
14793
14794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14795   void * jresult ;
14796   Dali::Vector2 *arg1 = 0 ;
14797   Dali::Property::Value *result = 0 ;
14798
14799   arg1 = (Dali::Vector2 *)jarg1;
14800   if (!arg1) {
14801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14802     return 0;
14803   }
14804   {
14805     try {
14806       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14807     } catch (std::out_of_range& e) {
14808       {
14809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14810       };
14811     } catch (std::exception& e) {
14812       {
14813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14814       };
14815     } catch (...) {
14816       {
14817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14818       };
14819     }
14820   }
14821   jresult = (void *)result;
14822   return jresult;
14823 }
14824
14825
14826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14827   void * jresult ;
14828   Dali::Vector3 *arg1 = 0 ;
14829   Dali::Property::Value *result = 0 ;
14830
14831   arg1 = (Dali::Vector3 *)jarg1;
14832   if (!arg1) {
14833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14834     return 0;
14835   }
14836   {
14837     try {
14838       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14839     } catch (std::out_of_range& e) {
14840       {
14841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14842       };
14843     } catch (std::exception& e) {
14844       {
14845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14846       };
14847     } catch (...) {
14848       {
14849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14850       };
14851     }
14852   }
14853   jresult = (void *)result;
14854   return jresult;
14855 }
14856
14857
14858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14859   void * jresult ;
14860   Dali::Vector4 *arg1 = 0 ;
14861   Dali::Property::Value *result = 0 ;
14862
14863   arg1 = (Dali::Vector4 *)jarg1;
14864   if (!arg1) {
14865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14866     return 0;
14867   }
14868   {
14869     try {
14870       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14871     } catch (std::out_of_range& e) {
14872       {
14873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14874       };
14875     } catch (std::exception& e) {
14876       {
14877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14878       };
14879     } catch (...) {
14880       {
14881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14882       };
14883     }
14884   }
14885   jresult = (void *)result;
14886   return jresult;
14887 }
14888
14889
14890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14891   void * jresult ;
14892   Dali::Matrix3 *arg1 = 0 ;
14893   Dali::Property::Value *result = 0 ;
14894
14895   arg1 = (Dali::Matrix3 *)jarg1;
14896   if (!arg1) {
14897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14898     return 0;
14899   }
14900   {
14901     try {
14902       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14903     } catch (std::out_of_range& e) {
14904       {
14905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14906       };
14907     } catch (std::exception& e) {
14908       {
14909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (...) {
14912       {
14913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14914       };
14915     }
14916   }
14917   jresult = (void *)result;
14918   return jresult;
14919 }
14920
14921
14922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14923   void * jresult ;
14924   Dali::Matrix *arg1 = 0 ;
14925   Dali::Property::Value *result = 0 ;
14926
14927   arg1 = (Dali::Matrix *)jarg1;
14928   if (!arg1) {
14929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14930     return 0;
14931   }
14932   {
14933     try {
14934       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14935     } catch (std::out_of_range& e) {
14936       {
14937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14938       };
14939     } catch (std::exception& e) {
14940       {
14941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14942       };
14943     } catch (...) {
14944       {
14945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14946       };
14947     }
14948   }
14949   jresult = (void *)result;
14950   return jresult;
14951 }
14952
14953
14954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14955   void * jresult ;
14956   Dali::Rect< int > *arg1 = 0 ;
14957   Dali::Property::Value *result = 0 ;
14958
14959   arg1 = (Dali::Rect< int > *)jarg1;
14960   if (!arg1) {
14961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14962     return 0;
14963   }
14964   {
14965     try {
14966       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14967     } catch (std::out_of_range& e) {
14968       {
14969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14970       };
14971     } catch (std::exception& e) {
14972       {
14973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14974       };
14975     } catch (...) {
14976       {
14977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14978       };
14979     }
14980   }
14981   jresult = (void *)result;
14982   return jresult;
14983 }
14984
14985
14986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
14987   void * jresult ;
14988   Dali::AngleAxis *arg1 = 0 ;
14989   Dali::Property::Value *result = 0 ;
14990
14991   arg1 = (Dali::AngleAxis *)jarg1;
14992   if (!arg1) {
14993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14994     return 0;
14995   }
14996   {
14997     try {
14998       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
14999     } catch (std::out_of_range& e) {
15000       {
15001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15002       };
15003     } catch (std::exception& e) {
15004       {
15005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15006       };
15007     } catch (...) {
15008       {
15009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15010       };
15011     }
15012   }
15013   jresult = (void *)result;
15014   return jresult;
15015 }
15016
15017
15018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15019   void * jresult ;
15020   Dali::Quaternion *arg1 = 0 ;
15021   Dali::Property::Value *result = 0 ;
15022
15023   arg1 = (Dali::Quaternion *)jarg1;
15024   if (!arg1) {
15025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15026     return 0;
15027   }
15028   {
15029     try {
15030       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15031     } catch (std::out_of_range& e) {
15032       {
15033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15034       };
15035     } catch (std::exception& e) {
15036       {
15037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (...) {
15040       {
15041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15042       };
15043     }
15044   }
15045   jresult = (void *)result;
15046   return jresult;
15047 }
15048
15049
15050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15051   void * jresult ;
15052   std::string *arg1 = 0 ;
15053   Dali::Property::Value *result = 0 ;
15054
15055   if (!jarg1) {
15056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15057     return 0;
15058   }
15059   std::string arg1_str(jarg1);
15060   arg1 = &arg1_str;
15061   {
15062     try {
15063       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15064     } catch (std::out_of_range& e) {
15065       {
15066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15067       };
15068     } catch (std::exception& e) {
15069       {
15070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (...) {
15073       {
15074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15075       };
15076     }
15077   }
15078   jresult = (void *)result;
15079
15080   //argout typemap for const std::string&
15081
15082   return jresult;
15083 }
15084
15085
15086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15087   void * jresult ;
15088   Dali::Property::Array *arg1 = 0 ;
15089   Dali::Property::Value *result = 0 ;
15090
15091   arg1 = (Dali::Property::Array *)jarg1;
15092   if (!arg1) {
15093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15094     return 0;
15095   }
15096   {
15097     try {
15098       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15099     } catch (std::out_of_range& e) {
15100       {
15101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15102       };
15103     } catch (std::exception& e) {
15104       {
15105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15106       };
15107     } catch (...) {
15108       {
15109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15110       };
15111     }
15112   }
15113   jresult = (void *)result;
15114   return jresult;
15115 }
15116
15117
15118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15119   void * jresult ;
15120   Dali::Property::Map *arg1 = 0 ;
15121   Dali::Property::Value *result = 0 ;
15122
15123   arg1 = (Dali::Property::Map *)jarg1;
15124   if (!arg1) {
15125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15126     return 0;
15127   }
15128   {
15129     try {
15130       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15131     } catch (std::out_of_range& e) {
15132       {
15133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15134       };
15135     } catch (std::exception& e) {
15136       {
15137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15138       };
15139     } catch (...) {
15140       {
15141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15142       };
15143     }
15144   }
15145   jresult = (void *)result;
15146   return jresult;
15147 }
15148
15149
15150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15151   void * jresult ;
15152   Dali::Property::Type arg1 ;
15153   Dali::Property::Value *result = 0 ;
15154
15155   arg1 = (Dali::Property::Type)jarg1;
15156   {
15157     try {
15158       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15159     } catch (std::out_of_range& e) {
15160       {
15161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15162       };
15163     } catch (std::exception& e) {
15164       {
15165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15166       };
15167     } catch (...) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15170       };
15171     }
15172   }
15173   jresult = (void *)result;
15174   return jresult;
15175 }
15176
15177
15178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15179   void * jresult ;
15180   Dali::Property::Value *arg1 = 0 ;
15181   Dali::Property::Value *result = 0 ;
15182
15183   arg1 = (Dali::Property::Value *)jarg1;
15184   if (!arg1) {
15185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15186     return 0;
15187   }
15188   {
15189     try {
15190       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15191     } catch (std::out_of_range& e) {
15192       {
15193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15194       };
15195     } catch (std::exception& e) {
15196       {
15197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15198       };
15199     } catch (...) {
15200       {
15201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15202       };
15203     }
15204   }
15205   jresult = (void *)result;
15206   return jresult;
15207 }
15208
15209
15210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15211   void * jresult ;
15212   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15213   Dali::Property::Value *arg2 = 0 ;
15214   Dali::Property::Value *result = 0 ;
15215
15216   arg1 = (Dali::Property::Value *)jarg1;
15217   arg2 = (Dali::Property::Value *)jarg2;
15218   if (!arg2) {
15219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15220     return 0;
15221   }
15222   {
15223     try {
15224       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15225     } catch (std::out_of_range& e) {
15226       {
15227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15228       };
15229     } catch (std::exception& e) {
15230       {
15231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15232       };
15233     } catch (...) {
15234       {
15235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15236       };
15237     }
15238   }
15239   jresult = (void *)result;
15240   return jresult;
15241 }
15242
15243
15244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15245   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15246
15247   arg1 = (Dali::Property::Value *)jarg1;
15248   {
15249     try {
15250       delete arg1;
15251     } catch (std::out_of_range& e) {
15252       {
15253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15254       };
15255     } catch (std::exception& e) {
15256       {
15257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15258       };
15259     } catch (...) {
15260       {
15261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15262       };
15263     }
15264   }
15265 }
15266
15267
15268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15269   int jresult ;
15270   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15271   Dali::Property::Type result;
15272
15273   arg1 = (Dali::Property::Value *)jarg1;
15274   {
15275     try {
15276       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15277     } catch (std::out_of_range& e) {
15278       {
15279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15280       };
15281     } catch (std::exception& e) {
15282       {
15283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15284       };
15285     } catch (...) {
15286       {
15287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15288       };
15289     }
15290   }
15291   jresult = (int)result;
15292   return jresult;
15293 }
15294
15295
15296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15297   unsigned int jresult ;
15298   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15299   bool *arg2 = 0 ;
15300   bool result;
15301
15302   arg1 = (Dali::Property::Value *)jarg1;
15303   arg2 = (bool *)jarg2;
15304   {
15305     try {
15306       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15307     } catch (std::out_of_range& e) {
15308       {
15309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15310       };
15311     } catch (std::exception& e) {
15312       {
15313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15314       };
15315     } catch (...) {
15316       {
15317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15318       };
15319     }
15320   }
15321   jresult = result;
15322   return jresult;
15323 }
15324
15325
15326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15327   unsigned int jresult ;
15328   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15329   float *arg2 = 0 ;
15330   bool result;
15331
15332   arg1 = (Dali::Property::Value *)jarg1;
15333   arg2 = (float *)jarg2;
15334   {
15335     try {
15336       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15337     } catch (std::out_of_range& e) {
15338       {
15339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15340       };
15341     } catch (std::exception& e) {
15342       {
15343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15344       };
15345     } catch (...) {
15346       {
15347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15348       };
15349     }
15350   }
15351   jresult = result;
15352   return jresult;
15353 }
15354
15355
15356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15357   unsigned int jresult ;
15358   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15359   int *arg2 = 0 ;
15360   bool result;
15361
15362   arg1 = (Dali::Property::Value *)jarg1;
15363   arg2 = (int *)jarg2;
15364   {
15365     try {
15366       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15367     } catch (std::out_of_range& e) {
15368       {
15369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15370       };
15371     } catch (std::exception& e) {
15372       {
15373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15374       };
15375     } catch (...) {
15376       {
15377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15378       };
15379     }
15380   }
15381   jresult = result;
15382   return jresult;
15383 }
15384
15385
15386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15387   unsigned int jresult ;
15388   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15389   Dali::Rect< int > *arg2 = 0 ;
15390   bool result;
15391
15392   arg1 = (Dali::Property::Value *)jarg1;
15393   arg2 = (Dali::Rect< int > *)jarg2;
15394   if (!arg2) {
15395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15396     return 0;
15397   }
15398   {
15399     try {
15400       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15401     } catch (std::out_of_range& e) {
15402       {
15403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15404       };
15405     } catch (std::exception& e) {
15406       {
15407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15408       };
15409     } catch (...) {
15410       {
15411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15412       };
15413     }
15414   }
15415   jresult = result;
15416   return jresult;
15417 }
15418
15419
15420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15421   unsigned int jresult ;
15422   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15423   Dali::Vector2 *arg2 = 0 ;
15424   bool result;
15425
15426   arg1 = (Dali::Property::Value *)jarg1;
15427   arg2 = (Dali::Vector2 *)jarg2;
15428   if (!arg2) {
15429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15430     return 0;
15431   }
15432   {
15433     try {
15434       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15435     } catch (std::out_of_range& e) {
15436       {
15437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15438       };
15439     } catch (std::exception& e) {
15440       {
15441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15442       };
15443     } catch (...) {
15444       {
15445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15446       };
15447     }
15448   }
15449   jresult = result;
15450   return jresult;
15451 }
15452
15453
15454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15455   unsigned int jresult ;
15456   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15457   Dali::Vector3 *arg2 = 0 ;
15458   bool result;
15459
15460   arg1 = (Dali::Property::Value *)jarg1;
15461   arg2 = (Dali::Vector3 *)jarg2;
15462   if (!arg2) {
15463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15464     return 0;
15465   }
15466   {
15467     try {
15468       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15469     } catch (std::out_of_range& e) {
15470       {
15471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15472       };
15473     } catch (std::exception& e) {
15474       {
15475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15476       };
15477     } catch (...) {
15478       {
15479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15480       };
15481     }
15482   }
15483   jresult = result;
15484   return jresult;
15485 }
15486
15487
15488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15489   unsigned int jresult ;
15490   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15491   Dali::Vector4 *arg2 = 0 ;
15492   bool result;
15493
15494   arg1 = (Dali::Property::Value *)jarg1;
15495   arg2 = (Dali::Vector4 *)jarg2;
15496   if (!arg2) {
15497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15498     return 0;
15499   }
15500   {
15501     try {
15502       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15503     } catch (std::out_of_range& e) {
15504       {
15505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15506       };
15507     } catch (std::exception& e) {
15508       {
15509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15510       };
15511     } catch (...) {
15512       {
15513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15514       };
15515     }
15516   }
15517   jresult = result;
15518   return jresult;
15519 }
15520
15521
15522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15523   unsigned int jresult ;
15524   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15525   Dali::Matrix3 *arg2 = 0 ;
15526   bool result;
15527
15528   arg1 = (Dali::Property::Value *)jarg1;
15529   arg2 = (Dali::Matrix3 *)jarg2;
15530   if (!arg2) {
15531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15532     return 0;
15533   }
15534   {
15535     try {
15536       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15537     } catch (std::out_of_range& e) {
15538       {
15539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15540       };
15541     } catch (std::exception& e) {
15542       {
15543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15544       };
15545     } catch (...) {
15546       {
15547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15548       };
15549     }
15550   }
15551   jresult = result;
15552   return jresult;
15553 }
15554
15555
15556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15557   unsigned int jresult ;
15558   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15559   Dali::Matrix *arg2 = 0 ;
15560   bool result;
15561
15562   arg1 = (Dali::Property::Value *)jarg1;
15563   arg2 = (Dali::Matrix *)jarg2;
15564   if (!arg2) {
15565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15566     return 0;
15567   }
15568   {
15569     try {
15570       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15571     } catch (std::out_of_range& e) {
15572       {
15573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15574       };
15575     } catch (std::exception& e) {
15576       {
15577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15578       };
15579     } catch (...) {
15580       {
15581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15582       };
15583     }
15584   }
15585   jresult = result;
15586   return jresult;
15587 }
15588
15589
15590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15591   unsigned int jresult ;
15592   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15593   Dali::AngleAxis *arg2 = 0 ;
15594   bool result;
15595
15596   arg1 = (Dali::Property::Value *)jarg1;
15597   arg2 = (Dali::AngleAxis *)jarg2;
15598   if (!arg2) {
15599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15600     return 0;
15601   }
15602   {
15603     try {
15604       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15605     } catch (std::out_of_range& e) {
15606       {
15607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15608       };
15609     } catch (std::exception& e) {
15610       {
15611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15612       };
15613     } catch (...) {
15614       {
15615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15616       };
15617     }
15618   }
15619   jresult = result;
15620   return jresult;
15621 }
15622
15623
15624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15625   unsigned int jresult ;
15626   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15627   Dali::Quaternion *arg2 = 0 ;
15628   bool result;
15629
15630   arg1 = (Dali::Property::Value *)jarg1;
15631   arg2 = (Dali::Quaternion *)jarg2;
15632   if (!arg2) {
15633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15634     return 0;
15635   }
15636   {
15637     try {
15638       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15639     } catch (std::out_of_range& e) {
15640       {
15641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15642       };
15643     } catch (std::exception& e) {
15644       {
15645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15646       };
15647     } catch (...) {
15648       {
15649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15650       };
15651     }
15652   }
15653   jresult = result;
15654   return jresult;
15655 }
15656
15657
15658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15659   unsigned int jresult ;
15660   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15661   std::string *arg2 = 0 ;
15662   bool result;
15663
15664   arg1 = (Dali::Property::Value *)jarg1;
15665
15666   //typemap in
15667   std::string temp;
15668   arg2 = &temp;
15669
15670   {
15671     try {
15672       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15673     } catch (std::out_of_range& e) {
15674       {
15675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15676       };
15677     } catch (std::exception& e) {
15678       {
15679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15680       };
15681     } catch (...) {
15682       {
15683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15684       };
15685     }
15686   }
15687   jresult = result;
15688
15689   //Typemap argout in c++ file.
15690   //This will convert c++ string to c# string
15691   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15692
15693   return jresult;
15694 }
15695
15696
15697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15698   unsigned int jresult ;
15699   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15700   Dali::Property::Array *arg2 = 0 ;
15701   bool result;
15702
15703   arg1 = (Dali::Property::Value *)jarg1;
15704   arg2 = (Dali::Property::Array *)jarg2;
15705   if (!arg2) {
15706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15707     return 0;
15708   }
15709   {
15710     try {
15711       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15712     } catch (std::out_of_range& e) {
15713       {
15714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15715       };
15716     } catch (std::exception& e) {
15717       {
15718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (...) {
15721       {
15722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15723       };
15724     }
15725   }
15726   jresult = result;
15727   return jresult;
15728 }
15729
15730
15731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15732   unsigned int jresult ;
15733   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15734   Dali::Property::Map *arg2 = 0 ;
15735   bool result;
15736
15737   arg1 = (Dali::Property::Value *)jarg1;
15738   arg2 = (Dali::Property::Map *)jarg2;
15739   if (!arg2) {
15740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15741     return 0;
15742   }
15743   {
15744     try {
15745       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15746     } catch (std::out_of_range& e) {
15747       {
15748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15749       };
15750     } catch (std::exception& e) {
15751       {
15752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15753       };
15754     } catch (...) {
15755       {
15756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15757       };
15758     }
15759   }
15760   jresult = result;
15761   return jresult;
15762 }
15763
15764
15765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15766   void * jresult ;
15767   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15768   Dali::Property::Array *result = 0 ;
15769
15770   arg1 = (Dali::Property::Value *)jarg1;
15771   {
15772     try {
15773       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15774     } catch (std::out_of_range& e) {
15775       {
15776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15777       };
15778     } catch (std::exception& e) {
15779       {
15780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15781       };
15782     } catch (...) {
15783       {
15784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15785       };
15786     }
15787   }
15788   jresult = (void *)result;
15789   return jresult;
15790 }
15791
15792
15793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15794   void * jresult ;
15795   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15796   Dali::Property::Map *result = 0 ;
15797
15798   arg1 = (Dali::Property::Value *)jarg1;
15799   {
15800     try {
15801       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15802     } catch (std::out_of_range& e) {
15803       {
15804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15805       };
15806     } catch (std::exception& e) {
15807       {
15808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15809       };
15810     } catch (...) {
15811       {
15812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15813       };
15814     }
15815   }
15816   jresult = (void *)result;
15817   return jresult;
15818 }
15819
15820
15821 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15822   char * jresult ;
15823   Dali::Property::Type arg1 ;
15824   char *result = 0 ;
15825
15826   arg1 = (Dali::Property::Type)jarg1;
15827   {
15828     try {
15829       result = (char *)Dali::PropertyTypes::GetName(arg1);
15830     } catch (std::out_of_range& e) {
15831       {
15832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15833       };
15834     } catch (std::exception& e) {
15835       {
15836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15837       };
15838     } catch (...) {
15839       {
15840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15841       };
15842     }
15843   }
15844   jresult = SWIG_csharp_string_callback((const char *)result);
15845   return jresult;
15846 }
15847
15848
15849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15850   unsigned int jresult ;
15851   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15852   std::string *arg2 = 0 ;
15853   Dali::Property::Map *arg3 = 0 ;
15854   bool result;
15855
15856   arg1 = (Dali::BaseObject *)jarg1;
15857   if (!jarg2) {
15858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15859     return 0;
15860   }
15861   std::string arg2_str(jarg2);
15862   arg2 = &arg2_str;
15863   arg3 = (Dali::Property::Map *)jarg3;
15864   if (!arg3) {
15865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15866     return 0;
15867   }
15868   {
15869     try {
15870       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15871     } catch (std::out_of_range& e) {
15872       {
15873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15874       };
15875     } catch (std::exception& e) {
15876       {
15877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15878       };
15879     } catch (...) {
15880       {
15881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15882       };
15883     }
15884   }
15885   jresult = result;
15886
15887   //argout typemap for const std::string&
15888
15889   return jresult;
15890 }
15891
15892
15893 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15894   char * jresult ;
15895   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15896   std::string *result = 0 ;
15897
15898   arg1 = (Dali::BaseObject *)jarg1;
15899   {
15900     try {
15901       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15902     } catch (std::out_of_range& e) {
15903       {
15904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15905       };
15906     } catch (std::exception& e) {
15907       {
15908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15909       };
15910     } catch (...) {
15911       {
15912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15913       };
15914     }
15915   }
15916   jresult = SWIG_csharp_string_callback(result->c_str());
15917   return jresult;
15918 }
15919
15920
15921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15922   unsigned int jresult ;
15923   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15924   Dali::TypeInfo *arg2 = 0 ;
15925   bool result;
15926
15927   arg1 = (Dali::BaseObject *)jarg1;
15928   arg2 = (Dali::TypeInfo *)jarg2;
15929   if (!arg2) {
15930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15931     return 0;
15932   }
15933   {
15934     try {
15935       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15936     } catch (std::out_of_range& e) {
15937       {
15938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15939       };
15940     } catch (std::exception& e) {
15941       {
15942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15943       };
15944     } catch (...) {
15945       {
15946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15947       };
15948     }
15949   }
15950   jresult = result;
15951   return jresult;
15952 }
15953
15954
15955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15956   unsigned int jresult ;
15957   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15958   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15959   std::string *arg3 = 0 ;
15960   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15961   bool result;
15962
15963   arg1 = (Dali::BaseObject *)jarg1;
15964   arg2 = (ConnectionTrackerInterface *)jarg2;
15965   if (!jarg3) {
15966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15967     return 0;
15968   }
15969   std::string arg3_str(jarg3);
15970   arg3 = &arg3_str;
15971   arg4 = (FunctorDelegate *)jarg4;
15972   {
15973     try {
15974       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15975     } catch (std::out_of_range& e) {
15976       {
15977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15978       };
15979     } catch (std::exception& e) {
15980       {
15981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15982       };
15983     } catch (...) {
15984       {
15985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15986       };
15987     }
15988   }
15989   jresult = result;
15990
15991   //argout typemap for const std::string&
15992
15993   return jresult;
15994 }
15995
15996
15997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
15998   void * jresult ;
15999   Dali::BaseHandle *arg1 = 0 ;
16000   Dali::BaseObject *result = 0 ;
16001
16002   arg1 = (Dali::BaseHandle *)jarg1;
16003   if (!arg1) {
16004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16005     return 0;
16006   }
16007   {
16008     try {
16009       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16010     } catch (std::out_of_range& e) {
16011       {
16012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16013       };
16014     } catch (std::exception& e) {
16015       {
16016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16017       };
16018     } catch (...) {
16019       {
16020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16021       };
16022     }
16023   }
16024   jresult = (void *)result;
16025   return jresult;
16026 }
16027
16028
16029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16030   void * jresult ;
16031   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16032   Dali::BaseHandle *result = 0 ;
16033
16034   arg1 = (Dali::BaseObject *)jarg1;
16035   {
16036     try {
16037       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16038     } catch (std::out_of_range& e) {
16039       {
16040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16041       };
16042     } catch (std::exception& e) {
16043       {
16044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16045       };
16046     } catch (...) {
16047       {
16048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16049       };
16050     }
16051   }
16052   jresult = (void *)result;
16053   return jresult;
16054 }
16055
16056
16057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16058   void * jresult ;
16059   Dali::BaseHandle *result = 0 ;
16060
16061   {
16062     try {
16063       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16064     } catch (std::out_of_range& e) {
16065       {
16066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16067       };
16068     } catch (std::exception& e) {
16069       {
16070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16071       };
16072     } catch (...) {
16073       {
16074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16075       };
16076     }
16077   }
16078   jresult = (void *)result;
16079   return jresult;
16080 }
16081
16082
16083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16084   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16085
16086   arg1 = (Dali::BaseHandle *)jarg1;
16087   {
16088     try {
16089       delete arg1;
16090     } catch (std::out_of_range& e) {
16091       {
16092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16093       };
16094     } catch (std::exception& e) {
16095       {
16096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16097       };
16098     } catch (...) {
16099       {
16100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16101       };
16102     }
16103   }
16104 }
16105
16106
16107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16108   void * jresult ;
16109   Dali::BaseHandle *arg1 = 0 ;
16110   Dali::BaseHandle *result = 0 ;
16111
16112   arg1 = (Dali::BaseHandle *)jarg1;
16113   if (!arg1) {
16114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16115     return 0;
16116   }
16117   {
16118     try {
16119       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16120     } catch (std::out_of_range& e) {
16121       {
16122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16123       };
16124     } catch (std::exception& e) {
16125       {
16126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16127       };
16128     } catch (...) {
16129       {
16130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16131       };
16132     }
16133   }
16134   jresult = (void *)result;
16135   return jresult;
16136 }
16137
16138
16139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16140   void * jresult ;
16141   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16142   Dali::BaseHandle *arg2 = 0 ;
16143   Dali::BaseHandle *result = 0 ;
16144
16145   arg1 = (Dali::BaseHandle *)jarg1;
16146   arg2 = (Dali::BaseHandle *)jarg2;
16147   if (!arg2) {
16148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16149     return 0;
16150   }
16151   {
16152     try {
16153       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16154     } catch (std::out_of_range& e) {
16155       {
16156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16157       };
16158     } catch (std::exception& e) {
16159       {
16160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16161       };
16162     } catch (...) {
16163       {
16164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16165       };
16166     }
16167   }
16168   jresult = (void *)result;
16169   return jresult;
16170 }
16171
16172
16173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16174   unsigned int jresult ;
16175   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16176   std::string *arg2 = 0 ;
16177   Dali::Property::Map *arg3 = 0 ;
16178   bool result;
16179
16180   arg1 = (Dali::BaseHandle *)jarg1;
16181   if (!jarg2) {
16182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16183     return 0;
16184   }
16185   std::string arg2_str(jarg2);
16186   arg2 = &arg2_str;
16187   arg3 = (Dali::Property::Map *)jarg3;
16188   if (!arg3) {
16189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16190     return 0;
16191   }
16192   {
16193     try {
16194       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16195     } catch (std::out_of_range& e) {
16196       {
16197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16198       };
16199     } catch (std::exception& e) {
16200       {
16201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16202       };
16203     } catch (...) {
16204       {
16205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16206       };
16207     }
16208   }
16209   jresult = result;
16210
16211   //argout typemap for const std::string&
16212
16213   return jresult;
16214 }
16215
16216
16217 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16218   char * jresult ;
16219   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16220   std::string *result = 0 ;
16221
16222   arg1 = (Dali::BaseHandle *)jarg1;
16223   {
16224     try {
16225       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16226     } catch (std::out_of_range& e) {
16227       {
16228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16229       };
16230     } catch (std::exception& e) {
16231       {
16232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16233       };
16234     } catch (...) {
16235       {
16236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16237       };
16238     }
16239   }
16240   jresult = SWIG_csharp_string_callback(result->c_str());
16241   return jresult;
16242 }
16243
16244
16245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16246   unsigned int jresult ;
16247   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16248   Dali::TypeInfo *arg2 = 0 ;
16249   bool result;
16250
16251   arg1 = (Dali::BaseHandle *)jarg1;
16252   arg2 = (Dali::TypeInfo *)jarg2;
16253   if (!arg2) {
16254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16255     return 0;
16256   }
16257   {
16258     try {
16259       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16260     } catch (std::out_of_range& e) {
16261       {
16262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16263       };
16264     } catch (std::exception& e) {
16265       {
16266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16267       };
16268     } catch (...) {
16269       {
16270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16271       };
16272     }
16273   }
16274   jresult = result;
16275   return jresult;
16276 }
16277
16278
16279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16280   void * jresult ;
16281   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16282   Dali::BaseObject *result = 0 ;
16283
16284   arg1 = (Dali::BaseHandle *)jarg1;
16285   {
16286     try {
16287       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16288     } catch (std::out_of_range& e) {
16289       {
16290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16291       };
16292     } catch (std::exception& e) {
16293       {
16294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16295       };
16296     } catch (...) {
16297       {
16298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16299       };
16300     }
16301   }
16302   jresult = (void *)result;
16303   return jresult;
16304 }
16305
16306
16307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16308   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16309
16310   arg1 = (Dali::BaseHandle *)jarg1;
16311   {
16312     try {
16313       (arg1)->Reset();
16314     } catch (std::out_of_range& e) {
16315       {
16316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16317       };
16318     } catch (std::exception& e) {
16319       {
16320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16321       };
16322     } catch (...) {
16323       {
16324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16325       };
16326     }
16327   }
16328 }
16329
16330
16331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16332   unsigned int jresult ;
16333   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16334   Dali::BaseHandle *arg2 = 0 ;
16335   bool result;
16336
16337   arg1 = (Dali::BaseHandle *)jarg1;
16338   arg2 = (Dali::BaseHandle *)jarg2;
16339   if (!arg2) {
16340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16341     return 0;
16342   }
16343   {
16344     try {
16345       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16346     } catch (std::out_of_range& e) {
16347       {
16348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16349       };
16350     } catch (std::exception& e) {
16351       {
16352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16353       };
16354     } catch (...) {
16355       {
16356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16357       };
16358     }
16359   }
16360   jresult = result;
16361   return jresult;
16362 }
16363
16364
16365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16366   unsigned int jresult ;
16367   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16368   Dali::BaseHandle *arg2 = 0 ;
16369   bool result;
16370
16371   arg1 = (Dali::BaseHandle *)jarg1;
16372   arg2 = (Dali::BaseHandle *)jarg2;
16373   if (!arg2) {
16374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16375     return 0;
16376   }
16377   {
16378     try {
16379       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16380     } catch (std::out_of_range& e) {
16381       {
16382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16383       };
16384     } catch (std::exception& e) {
16385       {
16386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16387       };
16388     } catch (...) {
16389       {
16390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16391       };
16392     }
16393   }
16394   jresult = result;
16395   return jresult;
16396 }
16397
16398
16399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16400   void * jresult ;
16401   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16402   Dali::RefObject *result = 0 ;
16403
16404   arg1 = (Dali::BaseHandle *)jarg1;
16405   {
16406     try {
16407       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16408     } catch (std::out_of_range& e) {
16409       {
16410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16411       };
16412     } catch (std::exception& e) {
16413       {
16414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16415       };
16416     } catch (...) {
16417       {
16418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16419       };
16420     }
16421   }
16422   jresult = (void *)result;
16423   return jresult;
16424 }
16425
16426
16427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16428   unsigned int jresult ;
16429   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16430   bool result;
16431
16432   arg1 = (Dali::BaseHandle *)jarg1;
16433   {
16434     try {
16435       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16436     } catch (std::out_of_range& e) {
16437       {
16438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16439       };
16440     } catch (std::exception& e) {
16441       {
16442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16443       };
16444     } catch (...) {
16445       {
16446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16447       };
16448     }
16449   }
16450   jresult = result;
16451   return jresult;
16452 }
16453
16454
16455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16456   unsigned int jresult ;
16457   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16458   Dali::BaseHandle *arg2 = 0 ;
16459   bool result;
16460
16461   arg1 = (Dali::BaseHandle *)jarg1;
16462   arg2 = (Dali::BaseHandle *)jarg2;
16463   if (!arg2) {
16464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16465     return 0;
16466   }
16467   {
16468     try {
16469       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16470     } catch (std::out_of_range& e) {
16471       {
16472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16473       };
16474     } catch (std::exception& e) {
16475       {
16476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16477       };
16478     } catch (...) {
16479       {
16480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16481       };
16482     }
16483   }
16484   jresult = result;
16485   return jresult;
16486 }
16487
16488
16489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16490   unsigned int jresult ;
16491   Dali::BaseHandle *arg1 = 0 ;
16492   Dali::BaseHandle *arg2 = 0 ;
16493   bool result;
16494
16495   arg1 = (Dali::BaseHandle *)jarg1;
16496   if (!arg1) {
16497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16498     return 0;
16499   }
16500   arg2 = (Dali::BaseHandle *)jarg2;
16501   if (!arg2) {
16502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16503     return 0;
16504   }
16505   {
16506     try {
16507       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16508     } catch (std::out_of_range& e) {
16509       {
16510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16511       };
16512     } catch (std::exception& e) {
16513       {
16514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16515       };
16516     } catch (...) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16519       };
16520     }
16521   }
16522   jresult = result;
16523   return jresult;
16524 }
16525
16526
16527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16528   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16529
16530   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16531   {
16532     try {
16533       delete arg1;
16534     } catch (std::out_of_range& e) {
16535       {
16536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16537       };
16538     } catch (std::exception& e) {
16539       {
16540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16541       };
16542     } catch (...) {
16543       {
16544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16545       };
16546     }
16547   }
16548 }
16549
16550
16551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16552   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16553   SlotObserver *arg2 = (SlotObserver *) 0 ;
16554   CallbackBase *arg3 = (CallbackBase *) 0 ;
16555
16556   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16557   arg2 = (SlotObserver *)jarg2;
16558   arg3 = (CallbackBase *)jarg3;
16559   {
16560     try {
16561       (arg1)->SignalConnected(arg2,arg3);
16562     } catch (std::out_of_range& e) {
16563       {
16564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16565       };
16566     } catch (std::exception& e) {
16567       {
16568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16569       };
16570     } catch (...) {
16571       {
16572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16573       };
16574     }
16575   }
16576 }
16577
16578
16579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16580   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16581
16582   arg1 = (Dali::SignalObserver *)jarg1;
16583   {
16584     try {
16585       delete arg1;
16586     } catch (std::out_of_range& e) {
16587       {
16588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16589       };
16590     } catch (std::exception& e) {
16591       {
16592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16593       };
16594     } catch (...) {
16595       {
16596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16597       };
16598     }
16599   }
16600 }
16601
16602
16603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16604   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16605   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16606   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16607
16608   arg1 = (Dali::SignalObserver *)jarg1;
16609   arg2 = (Dali::SlotObserver *)jarg2;
16610   arg3 = (Dali::CallbackBase *)jarg3;
16611   {
16612     try {
16613       (arg1)->SignalDisconnected(arg2,arg3);
16614     } catch (std::out_of_range& e) {
16615       {
16616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16617       };
16618     } catch (std::exception& e) {
16619       {
16620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16621       };
16622     } catch (...) {
16623       {
16624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16625       };
16626     }
16627   }
16628 }
16629
16630
16631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16632   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16633
16634   arg1 = (Dali::SlotObserver *)jarg1;
16635   {
16636     try {
16637       delete arg1;
16638     } catch (std::out_of_range& e) {
16639       {
16640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16641       };
16642     } catch (std::exception& e) {
16643       {
16644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16645       };
16646     } catch (...) {
16647       {
16648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16649       };
16650     }
16651   }
16652 }
16653
16654
16655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16656   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16657   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16658
16659   arg1 = (Dali::SlotObserver *)jarg1;
16660   arg2 = (Dali::CallbackBase *)jarg2;
16661   {
16662     try {
16663       (arg1)->SlotDisconnected(arg2);
16664     } catch (std::out_of_range& e) {
16665       {
16666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16667       };
16668     } catch (std::exception& e) {
16669       {
16670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16671       };
16672     } catch (...) {
16673       {
16674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16675       };
16676     }
16677   }
16678 }
16679
16680
16681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16682   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16683
16684   arg1 = (Dali::ConnectionTracker *)jarg1;
16685   {
16686     try {
16687       delete arg1;
16688     } catch (std::out_of_range& e) {
16689       {
16690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16691       };
16692     } catch (std::exception& e) {
16693       {
16694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16695       };
16696     } catch (...) {
16697       {
16698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16699       };
16700     }
16701   }
16702 }
16703
16704
16705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16706   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16707
16708   arg1 = (Dali::ConnectionTracker *)jarg1;
16709   {
16710     try {
16711       (arg1)->DisconnectAll();
16712     } catch (std::out_of_range& e) {
16713       {
16714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16715       };
16716     } catch (std::exception& e) {
16717       {
16718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16719       };
16720     } catch (...) {
16721       {
16722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16723       };
16724     }
16725   }
16726 }
16727
16728
16729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16730   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16731   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16732   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16733
16734   arg1 = (Dali::ConnectionTracker *)jarg1;
16735   arg2 = (Dali::SlotObserver *)jarg2;
16736   arg3 = (Dali::CallbackBase *)jarg3;
16737   {
16738     try {
16739       (arg1)->SignalConnected(arg2,arg3);
16740     } catch (std::out_of_range& e) {
16741       {
16742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16743       };
16744     } catch (std::exception& e) {
16745       {
16746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16747       };
16748     } catch (...) {
16749       {
16750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16751       };
16752     }
16753   }
16754 }
16755
16756
16757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16758   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16759   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16760   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16761
16762   arg1 = (Dali::ConnectionTracker *)jarg1;
16763   arg2 = (Dali::SlotObserver *)jarg2;
16764   arg3 = (Dali::CallbackBase *)jarg3;
16765   {
16766     try {
16767       (arg1)->SignalDisconnected(arg2,arg3);
16768     } catch (std::out_of_range& e) {
16769       {
16770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16771       };
16772     } catch (std::exception& e) {
16773       {
16774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16775       };
16776     } catch (...) {
16777       {
16778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16779       };
16780     }
16781   }
16782 }
16783
16784
16785 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16786   unsigned long jresult ;
16787   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16788   std::size_t result;
16789
16790   arg1 = (Dali::ConnectionTracker *)jarg1;
16791   {
16792     try {
16793       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16794     } catch (std::out_of_range& e) {
16795       {
16796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16797       };
16798     } catch (std::exception& e) {
16799       {
16800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16801       };
16802     } catch (...) {
16803       {
16804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16805       };
16806     }
16807   }
16808   jresult = (unsigned long)result;
16809   return jresult;
16810 }
16811
16812
16813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16814   void * jresult ;
16815   Dali::ObjectRegistry *result = 0 ;
16816
16817   {
16818     try {
16819       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16820     } catch (std::out_of_range& e) {
16821       {
16822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16823       };
16824     } catch (std::exception& e) {
16825       {
16826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16827       };
16828     } catch (...) {
16829       {
16830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16831       };
16832     }
16833   }
16834   jresult = (void *)result;
16835   return jresult;
16836 }
16837
16838
16839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16840   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16841
16842   arg1 = (Dali::ObjectRegistry *)jarg1;
16843   {
16844     try {
16845       delete arg1;
16846     } catch (std::out_of_range& e) {
16847       {
16848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16849       };
16850     } catch (std::exception& e) {
16851       {
16852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16853       };
16854     } catch (...) {
16855       {
16856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16857       };
16858     }
16859   }
16860 }
16861
16862
16863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16864   void * jresult ;
16865   Dali::ObjectRegistry *arg1 = 0 ;
16866   Dali::ObjectRegistry *result = 0 ;
16867
16868   arg1 = (Dali::ObjectRegistry *)jarg1;
16869   if (!arg1) {
16870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16871     return 0;
16872   }
16873   {
16874     try {
16875       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16876     } catch (std::out_of_range& e) {
16877       {
16878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16879       };
16880     } catch (std::exception& e) {
16881       {
16882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16883       };
16884     } catch (...) {
16885       {
16886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16887       };
16888     }
16889   }
16890   jresult = (void *)result;
16891   return jresult;
16892 }
16893
16894
16895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16896   void * jresult ;
16897   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16898   Dali::ObjectRegistry *arg2 = 0 ;
16899   Dali::ObjectRegistry *result = 0 ;
16900
16901   arg1 = (Dali::ObjectRegistry *)jarg1;
16902   arg2 = (Dali::ObjectRegistry *)jarg2;
16903   if (!arg2) {
16904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16905     return 0;
16906   }
16907   {
16908     try {
16909       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16910     } catch (std::out_of_range& e) {
16911       {
16912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16913       };
16914     } catch (std::exception& e) {
16915       {
16916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16917       };
16918     } catch (...) {
16919       {
16920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16921       };
16922     }
16923   }
16924   jresult = (void *)result;
16925   return jresult;
16926 }
16927
16928
16929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16930   void * jresult ;
16931   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16932   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16933
16934   arg1 = (Dali::ObjectRegistry *)jarg1;
16935   {
16936     try {
16937       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16938     } catch (std::out_of_range& e) {
16939       {
16940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16941       };
16942     } catch (std::exception& e) {
16943       {
16944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16945       };
16946     } catch (...) {
16947       {
16948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16949       };
16950     }
16951   }
16952   jresult = (void *)result;
16953   return jresult;
16954 }
16955
16956
16957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16958   void * jresult ;
16959   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16960   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16961
16962   arg1 = (Dali::ObjectRegistry *)jarg1;
16963   {
16964     try {
16965       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16966     } catch (std::out_of_range& e) {
16967       {
16968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16969       };
16970     } catch (std::exception& e) {
16971       {
16972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16973       };
16974     } catch (...) {
16975       {
16976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16977       };
16978     }
16979   }
16980   jresult = (void *)result;
16981   return jresult;
16982 }
16983
16984
16985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
16986   void * jresult ;
16987   Dali::PropertyCondition *result = 0 ;
16988
16989   {
16990     try {
16991       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
16992     } catch (std::out_of_range& e) {
16993       {
16994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16995       };
16996     } catch (std::exception& e) {
16997       {
16998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16999       };
17000     } catch (...) {
17001       {
17002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17003       };
17004     }
17005   }
17006   jresult = (void *)result;
17007   return jresult;
17008 }
17009
17010
17011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17012   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17013
17014   arg1 = (Dali::PropertyCondition *)jarg1;
17015   {
17016     try {
17017       delete arg1;
17018     } catch (std::out_of_range& e) {
17019       {
17020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17021       };
17022     } catch (std::exception& e) {
17023       {
17024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17025       };
17026     } catch (...) {
17027       {
17028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17029       };
17030     }
17031   }
17032 }
17033
17034
17035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17036   void * jresult ;
17037   Dali::PropertyCondition *arg1 = 0 ;
17038   Dali::PropertyCondition *result = 0 ;
17039
17040   arg1 = (Dali::PropertyCondition *)jarg1;
17041   if (!arg1) {
17042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17043     return 0;
17044   }
17045   {
17046     try {
17047       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17048     } catch (std::out_of_range& e) {
17049       {
17050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17051       };
17052     } catch (std::exception& e) {
17053       {
17054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17055       };
17056     } catch (...) {
17057       {
17058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17059       };
17060     }
17061   }
17062   jresult = (void *)result;
17063   return jresult;
17064 }
17065
17066
17067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17068   void * jresult ;
17069   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17070   Dali::PropertyCondition *arg2 = 0 ;
17071   Dali::PropertyCondition *result = 0 ;
17072
17073   arg1 = (Dali::PropertyCondition *)jarg1;
17074   arg2 = (Dali::PropertyCondition *)jarg2;
17075   if (!arg2) {
17076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17077     return 0;
17078   }
17079   {
17080     try {
17081       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17082     } catch (std::out_of_range& e) {
17083       {
17084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17085       };
17086     } catch (std::exception& e) {
17087       {
17088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17089       };
17090     } catch (...) {
17091       {
17092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17093       };
17094     }
17095   }
17096   jresult = (void *)result;
17097   return jresult;
17098 }
17099
17100
17101 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17102   unsigned long jresult ;
17103   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17104   std::size_t result;
17105
17106   arg1 = (Dali::PropertyCondition *)jarg1;
17107   {
17108     try {
17109       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17110     } catch (std::out_of_range& e) {
17111       {
17112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17113       };
17114     } catch (std::exception& e) {
17115       {
17116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17117       };
17118     } catch (...) {
17119       {
17120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17121       };
17122     }
17123   }
17124   jresult = (unsigned long)result;
17125   return jresult;
17126 }
17127
17128
17129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17130   float jresult ;
17131   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17132   std::size_t arg2 ;
17133   float result;
17134
17135   arg1 = (Dali::PropertyCondition *)jarg1;
17136   arg2 = (std::size_t)jarg2;
17137   {
17138     try {
17139       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17140     } catch (std::out_of_range& e) {
17141       {
17142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17143       };
17144     } catch (std::exception& e) {
17145       {
17146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17147       };
17148     } catch (...) {
17149       {
17150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17151       };
17152     }
17153   }
17154   jresult = result;
17155   return jresult;
17156 }
17157
17158
17159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17160   void * jresult ;
17161   float arg1 ;
17162   Dali::PropertyCondition result;
17163
17164   arg1 = (float)jarg1;
17165   {
17166     try {
17167       result = Dali::LessThanCondition(arg1);
17168     } catch (std::out_of_range& e) {
17169       {
17170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17171       };
17172     } catch (std::exception& e) {
17173       {
17174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17175       };
17176     } catch (...) {
17177       {
17178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17179       };
17180     }
17181   }
17182   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17183   return jresult;
17184 }
17185
17186
17187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17188   void * jresult ;
17189   float arg1 ;
17190   Dali::PropertyCondition result;
17191
17192   arg1 = (float)jarg1;
17193   {
17194     try {
17195       result = Dali::GreaterThanCondition(arg1);
17196     } catch (std::out_of_range& e) {
17197       {
17198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17199       };
17200     } catch (std::exception& e) {
17201       {
17202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17203       };
17204     } catch (...) {
17205       {
17206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17207       };
17208     }
17209   }
17210   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17211   return jresult;
17212 }
17213
17214
17215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17216   void * jresult ;
17217   float arg1 ;
17218   float arg2 ;
17219   Dali::PropertyCondition result;
17220
17221   arg1 = (float)jarg1;
17222   arg2 = (float)jarg2;
17223   {
17224     try {
17225       result = Dali::InsideCondition(arg1,arg2);
17226     } catch (std::out_of_range& e) {
17227       {
17228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17229       };
17230     } catch (std::exception& e) {
17231       {
17232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17233       };
17234     } catch (...) {
17235       {
17236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17237       };
17238     }
17239   }
17240   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17241   return jresult;
17242 }
17243
17244
17245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17246   void * jresult ;
17247   float arg1 ;
17248   float arg2 ;
17249   Dali::PropertyCondition result;
17250
17251   arg1 = (float)jarg1;
17252   arg2 = (float)jarg2;
17253   {
17254     try {
17255       result = Dali::OutsideCondition(arg1,arg2);
17256     } catch (std::out_of_range& e) {
17257       {
17258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17259       };
17260     } catch (std::exception& e) {
17261       {
17262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17263       };
17264     } catch (...) {
17265       {
17266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17267       };
17268     }
17269   }
17270   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17271   return jresult;
17272 }
17273
17274
17275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17276   void * jresult ;
17277   float arg1 ;
17278   float arg2 ;
17279   Dali::PropertyCondition result;
17280
17281   arg1 = (float)jarg1;
17282   arg2 = (float)jarg2;
17283   {
17284     try {
17285       result = Dali::StepCondition(arg1,arg2);
17286     } catch (std::out_of_range& e) {
17287       {
17288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17289       };
17290     } catch (std::exception& e) {
17291       {
17292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17293       };
17294     } catch (...) {
17295       {
17296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17297       };
17298     }
17299   }
17300   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17301   return jresult;
17302 }
17303
17304
17305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17306   void * jresult ;
17307   float arg1 ;
17308   Dali::PropertyCondition result;
17309
17310   arg1 = (float)jarg1;
17311   {
17312     try {
17313       result = Dali::StepCondition(arg1);
17314     } catch (std::out_of_range& e) {
17315       {
17316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17317       };
17318     } catch (std::exception& e) {
17319       {
17320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17321       };
17322     } catch (...) {
17323       {
17324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17325       };
17326     }
17327   }
17328   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17329   return jresult;
17330 }
17331
17332
17333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17334   void * jresult ;
17335   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17336   Dali::PropertyCondition result;
17337
17338   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17339   if (!arg1) {
17340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17341     return 0;
17342   }
17343   {
17344     try {
17345       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17346     } catch (std::out_of_range& e) {
17347       {
17348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17349       };
17350     } catch (std::exception& e) {
17351       {
17352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17353       };
17354     } catch (...) {
17355       {
17356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17357       };
17358     }
17359   }
17360   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17361   return jresult;
17362 }
17363
17364
17365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17366   void * jresult ;
17367   Dali::PropertyNotification *result = 0 ;
17368
17369   {
17370     try {
17371       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17372     } catch (std::out_of_range& e) {
17373       {
17374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17375       };
17376     } catch (std::exception& e) {
17377       {
17378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17379       };
17380     } catch (...) {
17381       {
17382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17383       };
17384     }
17385   }
17386   jresult = (void *)result;
17387   return jresult;
17388 }
17389
17390
17391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17392   void * jresult ;
17393   Dali::BaseHandle arg1 ;
17394   Dali::BaseHandle *argp1 ;
17395   Dali::PropertyNotification result;
17396
17397   argp1 = (Dali::BaseHandle *)jarg1;
17398   if (!argp1) {
17399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17400     return 0;
17401   }
17402   arg1 = *argp1;
17403   {
17404     try {
17405       result = Dali::PropertyNotification::DownCast(arg1);
17406     } catch (std::out_of_range& e) {
17407       {
17408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17409       };
17410     } catch (std::exception& e) {
17411       {
17412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17413       };
17414     } catch (...) {
17415       {
17416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17417       };
17418     }
17419   }
17420   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17421   return jresult;
17422 }
17423
17424
17425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17426   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17427
17428   arg1 = (Dali::PropertyNotification *)jarg1;
17429   {
17430     try {
17431       delete arg1;
17432     } catch (std::out_of_range& e) {
17433       {
17434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17435       };
17436     } catch (std::exception& e) {
17437       {
17438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17439       };
17440     } catch (...) {
17441       {
17442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17443       };
17444     }
17445   }
17446 }
17447
17448
17449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17450   void * jresult ;
17451   Dali::PropertyNotification *arg1 = 0 ;
17452   Dali::PropertyNotification *result = 0 ;
17453
17454   arg1 = (Dali::PropertyNotification *)jarg1;
17455   if (!arg1) {
17456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17457     return 0;
17458   }
17459   {
17460     try {
17461       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17462     } catch (std::out_of_range& e) {
17463       {
17464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17465       };
17466     } catch (std::exception& e) {
17467       {
17468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17469       };
17470     } catch (...) {
17471       {
17472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17473       };
17474     }
17475   }
17476   jresult = (void *)result;
17477   return jresult;
17478 }
17479
17480
17481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17482   void * jresult ;
17483   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17484   Dali::PropertyNotification *arg2 = 0 ;
17485   Dali::PropertyNotification *result = 0 ;
17486
17487   arg1 = (Dali::PropertyNotification *)jarg1;
17488   arg2 = (Dali::PropertyNotification *)jarg2;
17489   if (!arg2) {
17490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17491     return 0;
17492   }
17493   {
17494     try {
17495       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17496     } catch (std::out_of_range& e) {
17497       {
17498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17499       };
17500     } catch (std::exception& e) {
17501       {
17502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17503       };
17504     } catch (...) {
17505       {
17506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17507       };
17508     }
17509   }
17510   jresult = (void *)result;
17511   return jresult;
17512 }
17513
17514
17515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17516   void * jresult ;
17517   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17518   Dali::PropertyCondition result;
17519
17520   arg1 = (Dali::PropertyNotification *)jarg1;
17521   {
17522     try {
17523       result = (arg1)->GetCondition();
17524     } catch (std::out_of_range& e) {
17525       {
17526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17527       };
17528     } catch (std::exception& e) {
17529       {
17530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17531       };
17532     } catch (...) {
17533       {
17534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17535       };
17536     }
17537   }
17538   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17539   return jresult;
17540 }
17541
17542
17543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17544   void * jresult ;
17545   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17546   Dali::Handle result;
17547
17548   arg1 = (Dali::PropertyNotification *)jarg1;
17549   {
17550     try {
17551       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17552     } catch (std::out_of_range& e) {
17553       {
17554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17555       };
17556     } catch (std::exception& e) {
17557       {
17558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17559       };
17560     } catch (...) {
17561       {
17562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17563       };
17564     }
17565   }
17566   jresult = new Dali::Handle((const Dali::Handle &)result);
17567   return jresult;
17568 }
17569
17570
17571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17572   int jresult ;
17573   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17574   Dali::Property::Index result;
17575
17576   arg1 = (Dali::PropertyNotification *)jarg1;
17577   {
17578     try {
17579       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17580     } catch (std::out_of_range& e) {
17581       {
17582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17583       };
17584     } catch (std::exception& e) {
17585       {
17586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17587       };
17588     } catch (...) {
17589       {
17590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17591       };
17592     }
17593   }
17594   jresult = result;
17595   return jresult;
17596 }
17597
17598
17599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17600   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17601   Dali::PropertyNotification::NotifyMode arg2 ;
17602
17603   arg1 = (Dali::PropertyNotification *)jarg1;
17604   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17605   {
17606     try {
17607       (arg1)->SetNotifyMode(arg2);
17608     } catch (std::out_of_range& e) {
17609       {
17610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17611       };
17612     } catch (std::exception& e) {
17613       {
17614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17615       };
17616     } catch (...) {
17617       {
17618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17619       };
17620     }
17621   }
17622 }
17623
17624
17625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17626   int jresult ;
17627   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17628   Dali::PropertyNotification::NotifyMode result;
17629
17630   arg1 = (Dali::PropertyNotification *)jarg1;
17631   {
17632     try {
17633       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17634     } catch (std::out_of_range& e) {
17635       {
17636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17637       };
17638     } catch (std::exception& e) {
17639       {
17640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17641       };
17642     } catch (...) {
17643       {
17644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17645       };
17646     }
17647   }
17648   jresult = (int)result;
17649   return jresult;
17650 }
17651
17652
17653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17654   unsigned int jresult ;
17655   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17656   bool result;
17657
17658   arg1 = (Dali::PropertyNotification *)jarg1;
17659   {
17660     try {
17661       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17662     } catch (std::out_of_range& e) {
17663       {
17664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17665       };
17666     } catch (std::exception& e) {
17667       {
17668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17669       };
17670     } catch (...) {
17671       {
17672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17673       };
17674     }
17675   }
17676   jresult = result;
17677   return jresult;
17678 }
17679
17680
17681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17682   void * jresult ;
17683   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17684   Dali::PropertyNotifySignalType *result = 0 ;
17685
17686   arg1 = (Dali::PropertyNotification *)jarg1;
17687   {
17688     try {
17689       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17690     } catch (std::out_of_range& e) {
17691       {
17692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17693       };
17694     } catch (std::exception& e) {
17695       {
17696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17697       };
17698     } catch (...) {
17699       {
17700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17701       };
17702     }
17703   }
17704   jresult = (void *)result;
17705   return jresult;
17706 }
17707
17708
17709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17710   void * jresult ;
17711   Dali::Handle *result = 0 ;
17712
17713   {
17714     try {
17715       result = (Dali::Handle *)new Dali::Handle();
17716     } catch (std::out_of_range& e) {
17717       {
17718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17719       };
17720     } catch (std::exception& e) {
17721       {
17722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17723       };
17724     } catch (...) {
17725       {
17726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17727       };
17728     }
17729   }
17730   jresult = (void *)result;
17731   return jresult;
17732 }
17733
17734
17735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17736   void * jresult ;
17737   Dali::Handle result;
17738
17739   {
17740     try {
17741       result = Dali::Handle::New();
17742     } catch (std::out_of_range& e) {
17743       {
17744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17745       };
17746     } catch (std::exception& e) {
17747       {
17748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17749       };
17750     } catch (...) {
17751       {
17752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17753       };
17754     }
17755   }
17756   jresult = new Dali::Handle((const Dali::Handle &)result);
17757   return jresult;
17758 }
17759
17760
17761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17762   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17763
17764   arg1 = (Dali::Handle *)jarg1;
17765   {
17766     try {
17767       delete arg1;
17768     } catch (std::out_of_range& e) {
17769       {
17770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17771       };
17772     } catch (std::exception& e) {
17773       {
17774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17775       };
17776     } catch (...) {
17777       {
17778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17779       };
17780     }
17781   }
17782 }
17783
17784
17785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17786   void * jresult ;
17787   Dali::Handle *arg1 = 0 ;
17788   Dali::Handle *result = 0 ;
17789
17790   arg1 = (Dali::Handle *)jarg1;
17791   if (!arg1) {
17792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17793     return 0;
17794   }
17795   {
17796     try {
17797       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17798     } catch (std::out_of_range& e) {
17799       {
17800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17801       };
17802     } catch (std::exception& e) {
17803       {
17804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17805       };
17806     } catch (...) {
17807       {
17808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17809       };
17810     }
17811   }
17812   jresult = (void *)result;
17813   return jresult;
17814 }
17815
17816
17817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17818   void * jresult ;
17819   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17820   Dali::Handle *arg2 = 0 ;
17821   Dali::Handle *result = 0 ;
17822
17823   arg1 = (Dali::Handle *)jarg1;
17824   arg2 = (Dali::Handle *)jarg2;
17825   if (!arg2) {
17826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17827     return 0;
17828   }
17829   {
17830     try {
17831       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17832     } catch (std::out_of_range& e) {
17833       {
17834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17835       };
17836     } catch (std::exception& e) {
17837       {
17838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17839       };
17840     } catch (...) {
17841       {
17842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17843       };
17844     }
17845   }
17846   jresult = (void *)result;
17847   return jresult;
17848 }
17849
17850
17851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17852   void * jresult ;
17853   Dali::BaseHandle arg1 ;
17854   Dali::BaseHandle *argp1 ;
17855   Dali::Handle result;
17856
17857   argp1 = (Dali::BaseHandle *)jarg1;
17858   if (!argp1) {
17859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17860     return 0;
17861   }
17862   arg1 = *argp1;
17863   {
17864     try {
17865       result = Dali::Handle::DownCast(arg1);
17866     } catch (std::out_of_range& e) {
17867       {
17868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17869       };
17870     } catch (std::exception& e) {
17871       {
17872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17873       };
17874     } catch (...) {
17875       {
17876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17877       };
17878     }
17879   }
17880   jresult = new Dali::Handle((const Dali::Handle &)result);
17881   return jresult;
17882 }
17883
17884
17885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17886   unsigned int jresult ;
17887   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17888   Dali::Handle::Capability arg2 ;
17889   bool result;
17890
17891   arg1 = (Dali::Handle *)jarg1;
17892   arg2 = (Dali::Handle::Capability)jarg2;
17893   {
17894     try {
17895       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17896     } catch (std::out_of_range& e) {
17897       {
17898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17899       };
17900     } catch (std::exception& e) {
17901       {
17902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17903       };
17904     } catch (...) {
17905       {
17906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17907       };
17908     }
17909   }
17910   jresult = result;
17911   return jresult;
17912 }
17913
17914
17915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17916   unsigned int jresult ;
17917   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17918   unsigned int result;
17919
17920   arg1 = (Dali::Handle *)jarg1;
17921   {
17922     try {
17923       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17924     } catch (std::out_of_range& e) {
17925       {
17926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17927       };
17928     } catch (std::exception& e) {
17929       {
17930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17931       };
17932     } catch (...) {
17933       {
17934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17935       };
17936     }
17937   }
17938   jresult = result;
17939   return jresult;
17940 }
17941
17942
17943 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17944   char * jresult ;
17945   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17946   Dali::Property::Index arg2 ;
17947   std::string result;
17948
17949   arg1 = (Dali::Handle *)jarg1;
17950   arg2 = (Dali::Property::Index)jarg2;
17951   {
17952     try {
17953       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17954     } catch (std::out_of_range& e) {
17955       {
17956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17957       };
17958     } catch (std::exception& e) {
17959       {
17960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17961       };
17962     } catch (...) {
17963       {
17964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17965       };
17966     }
17967   }
17968   jresult = SWIG_csharp_string_callback((&result)->c_str());
17969   return jresult;
17970 }
17971
17972
17973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17974   int jresult ;
17975   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17976   std::string *arg2 = 0 ;
17977   Dali::Property::Index result;
17978
17979   arg1 = (Dali::Handle *)jarg1;
17980   if (!jarg2) {
17981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17982     return 0;
17983   }
17984   std::string arg2_str(jarg2);
17985   arg2 = &arg2_str;
17986   {
17987     try {
17988       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
17989     } catch (std::out_of_range& e) {
17990       {
17991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17992       };
17993     } catch (std::exception& e) {
17994       {
17995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17996       };
17997     } catch (...) {
17998       {
17999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18000       };
18001     }
18002   }
18003   jresult = result;
18004
18005   //argout typemap for const std::string&
18006
18007   return jresult;
18008 }
18009
18010
18011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18012   unsigned int jresult ;
18013   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18014   Dali::Property::Index arg2 ;
18015   bool result;
18016
18017   arg1 = (Dali::Handle *)jarg1;
18018   arg2 = (Dali::Property::Index)jarg2;
18019   {
18020     try {
18021       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18022     } catch (std::out_of_range& e) {
18023       {
18024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18025       };
18026     } catch (std::exception& e) {
18027       {
18028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18029       };
18030     } catch (...) {
18031       {
18032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18033       };
18034     }
18035   }
18036   jresult = result;
18037   return jresult;
18038 }
18039
18040
18041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18042   unsigned int jresult ;
18043   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18044   Dali::Property::Index arg2 ;
18045   bool result;
18046
18047   arg1 = (Dali::Handle *)jarg1;
18048   arg2 = (Dali::Property::Index)jarg2;
18049   {
18050     try {
18051       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18052     } catch (std::out_of_range& e) {
18053       {
18054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18055       };
18056     } catch (std::exception& e) {
18057       {
18058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18059       };
18060     } catch (...) {
18061       {
18062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18063       };
18064     }
18065   }
18066   jresult = result;
18067   return jresult;
18068 }
18069
18070
18071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18072   unsigned int jresult ;
18073   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18074   Dali::Property::Index arg2 ;
18075   bool result;
18076
18077   arg1 = (Dali::Handle *)jarg1;
18078   arg2 = (Dali::Property::Index)jarg2;
18079   {
18080     try {
18081       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18082     } catch (std::out_of_range& e) {
18083       {
18084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18085       };
18086     } catch (std::exception& e) {
18087       {
18088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18089       };
18090     } catch (...) {
18091       {
18092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18093       };
18094     }
18095   }
18096   jresult = result;
18097   return jresult;
18098 }
18099
18100
18101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18102   int jresult ;
18103   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18104   Dali::Property::Index arg2 ;
18105   Dali::Property::Type result;
18106
18107   arg1 = (Dali::Handle *)jarg1;
18108   arg2 = (Dali::Property::Index)jarg2;
18109   {
18110     try {
18111       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18112     } catch (std::out_of_range& e) {
18113       {
18114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18115       };
18116     } catch (std::exception& e) {
18117       {
18118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18119       };
18120     } catch (...) {
18121       {
18122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18123       };
18124     }
18125   }
18126   jresult = (int)result;
18127   return jresult;
18128 }
18129
18130
18131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18132   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18133   Dali::Property::Index arg2 ;
18134   Dali::Property::Value *arg3 = 0 ;
18135
18136   arg1 = (Dali::Handle *)jarg1;
18137   arg2 = (Dali::Property::Index)jarg2;
18138   arg3 = (Dali::Property::Value *)jarg3;
18139   if (!arg3) {
18140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18141     return ;
18142   }
18143   {
18144     try {
18145       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18146     } catch (std::out_of_range& e) {
18147       {
18148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18149       };
18150     } catch (std::exception& e) {
18151       {
18152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18153       };
18154     } catch (...) {
18155       {
18156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18157       };
18158     }
18159   }
18160 }
18161
18162
18163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18164   int jresult ;
18165   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18166   std::string *arg2 = 0 ;
18167   Dali::Property::Value *arg3 = 0 ;
18168   Dali::Property::Index result;
18169
18170   arg1 = (Dali::Handle *)jarg1;
18171   if (!jarg2) {
18172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18173     return 0;
18174   }
18175   std::string arg2_str(jarg2);
18176   arg2 = &arg2_str;
18177   arg3 = (Dali::Property::Value *)jarg3;
18178   if (!arg3) {
18179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18180     return 0;
18181   }
18182   {
18183     try {
18184       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18185     } catch (std::out_of_range& e) {
18186       {
18187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18188       };
18189     } catch (std::exception& e) {
18190       {
18191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18192       };
18193     } catch (...) {
18194       {
18195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18196       };
18197     }
18198   }
18199   jresult = result;
18200
18201   //argout typemap for const std::string&
18202
18203   return jresult;
18204 }
18205
18206
18207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18208   int jresult ;
18209   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18210   std::string *arg2 = 0 ;
18211   Dali::Property::Value *arg3 = 0 ;
18212   Dali::Property::AccessMode arg4 ;
18213   Dali::Property::Index result;
18214
18215   arg1 = (Dali::Handle *)jarg1;
18216   if (!jarg2) {
18217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18218     return 0;
18219   }
18220   std::string arg2_str(jarg2);
18221   arg2 = &arg2_str;
18222   arg3 = (Dali::Property::Value *)jarg3;
18223   if (!arg3) {
18224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18225     return 0;
18226   }
18227   arg4 = (Dali::Property::AccessMode)jarg4;
18228   {
18229     try {
18230       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18231     } catch (std::out_of_range& e) {
18232       {
18233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18234       };
18235     } catch (std::exception& e) {
18236       {
18237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18238       };
18239     } catch (...) {
18240       {
18241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18242       };
18243     }
18244   }
18245   jresult = result;
18246
18247   //argout typemap for const std::string&
18248
18249   return jresult;
18250 }
18251
18252
18253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18254   void * jresult ;
18255   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18256   Dali::Property::Index arg2 ;
18257   Dali::Property::Value result;
18258
18259   arg1 = (Dali::Handle *)jarg1;
18260   arg2 = (Dali::Property::Index)jarg2;
18261   {
18262     try {
18263       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18264     } catch (std::out_of_range& e) {
18265       {
18266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18267       };
18268     } catch (std::exception& e) {
18269       {
18270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18271       };
18272     } catch (...) {
18273       {
18274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18275       };
18276     }
18277   }
18278   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18279   return jresult;
18280 }
18281
18282
18283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18284   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18285   Dali::Property::IndexContainer *arg2 = 0 ;
18286
18287   arg1 = (Dali::Handle *)jarg1;
18288   arg2 = (Dali::Property::IndexContainer *)jarg2;
18289   if (!arg2) {
18290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18291     return ;
18292   }
18293   {
18294     try {
18295       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18296     } catch (std::out_of_range& e) {
18297       {
18298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18299       };
18300     } catch (std::exception& e) {
18301       {
18302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18303       };
18304     } catch (...) {
18305       {
18306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18307       };
18308     }
18309   }
18310 }
18311
18312
18313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18314   void * jresult ;
18315   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18316   Dali::Property::Index arg2 ;
18317   Dali::PropertyCondition *arg3 = 0 ;
18318   Dali::PropertyNotification result;
18319
18320   arg1 = (Dali::Handle *)jarg1;
18321   arg2 = (Dali::Property::Index)jarg2;
18322   arg3 = (Dali::PropertyCondition *)jarg3;
18323   if (!arg3) {
18324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18325     return 0;
18326   }
18327   {
18328     try {
18329       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18330     } catch (std::out_of_range& e) {
18331       {
18332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18333       };
18334     } catch (std::exception& e) {
18335       {
18336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18337       };
18338     } catch (...) {
18339       {
18340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18341       };
18342     }
18343   }
18344   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18345   return jresult;
18346 }
18347
18348
18349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18350   void * jresult ;
18351   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18352   Dali::Property::Index arg2 ;
18353   int arg3 ;
18354   Dali::PropertyCondition *arg4 = 0 ;
18355   Dali::PropertyNotification result;
18356
18357   arg1 = (Dali::Handle *)jarg1;
18358   arg2 = (Dali::Property::Index)jarg2;
18359   arg3 = (int)jarg3;
18360   arg4 = (Dali::PropertyCondition *)jarg4;
18361   if (!arg4) {
18362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18363     return 0;
18364   }
18365   {
18366     try {
18367       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18368     } catch (std::out_of_range& e) {
18369       {
18370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18371       };
18372     } catch (std::exception& e) {
18373       {
18374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18375       };
18376     } catch (...) {
18377       {
18378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18379       };
18380     }
18381   }
18382   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18383   return jresult;
18384 }
18385
18386
18387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18388   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18389   Dali::PropertyNotification arg2 ;
18390   Dali::PropertyNotification *argp2 ;
18391
18392   arg1 = (Dali::Handle *)jarg1;
18393   argp2 = (Dali::PropertyNotification *)jarg2;
18394   if (!argp2) {
18395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18396     return ;
18397   }
18398   arg2 = *argp2;
18399   {
18400     try {
18401       (arg1)->RemovePropertyNotification(arg2);
18402     } catch (std::out_of_range& e) {
18403       {
18404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18405       };
18406     } catch (std::exception& e) {
18407       {
18408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18409       };
18410     } catch (...) {
18411       {
18412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18413       };
18414     }
18415   }
18416 }
18417
18418
18419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18420   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18421
18422   arg1 = (Dali::Handle *)jarg1;
18423   {
18424     try {
18425       (arg1)->RemovePropertyNotifications();
18426     } catch (std::out_of_range& e) {
18427       {
18428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18429       };
18430     } catch (std::exception& e) {
18431       {
18432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18433       };
18434     } catch (...) {
18435       {
18436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18437       };
18438     }
18439   }
18440 }
18441
18442
18443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18444   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18445
18446   arg1 = (Dali::Handle *)jarg1;
18447   {
18448     try {
18449       (arg1)->RemoveConstraints();
18450     } catch (std::out_of_range& e) {
18451       {
18452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18453       };
18454     } catch (std::exception& e) {
18455       {
18456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18457       };
18458     } catch (...) {
18459       {
18460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18461       };
18462     }
18463   }
18464 }
18465
18466
18467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18468   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18469   unsigned int arg2 ;
18470
18471   arg1 = (Dali::Handle *)jarg1;
18472   arg2 = (unsigned int)jarg2;
18473   {
18474     try {
18475       (arg1)->RemoveConstraints(arg2);
18476     } catch (std::out_of_range& e) {
18477       {
18478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18479       };
18480     } catch (std::exception& e) {
18481       {
18482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18483       };
18484     } catch (...) {
18485       {
18486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18487       };
18488     }
18489   }
18490 }
18491
18492
18493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18494   int jresult ;
18495   Dali::Property::Index result;
18496
18497   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18498   jresult = result;
18499   return jresult;
18500 }
18501
18502
18503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18504   void * jresult ;
18505   Dali::Handle result;
18506
18507   {
18508     try {
18509       result = Dali::WeightObject::New();
18510     } catch (std::out_of_range& e) {
18511       {
18512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18513       };
18514     } catch (std::exception& e) {
18515       {
18516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18517       };
18518     } catch (...) {
18519       {
18520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18521       };
18522     }
18523   }
18524   jresult = new Dali::Handle((const Dali::Handle &)result);
18525   return jresult;
18526 }
18527
18528
18529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18530   void * jresult ;
18531   Dali::TypeInfo *result = 0 ;
18532
18533   {
18534     try {
18535       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18536     } catch (std::out_of_range& e) {
18537       {
18538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18539       };
18540     } catch (std::exception& e) {
18541       {
18542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18543       };
18544     } catch (...) {
18545       {
18546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18547       };
18548     }
18549   }
18550   jresult = (void *)result;
18551   return jresult;
18552 }
18553
18554
18555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18556   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18557
18558   arg1 = (Dali::TypeInfo *)jarg1;
18559   {
18560     try {
18561       delete arg1;
18562     } catch (std::out_of_range& e) {
18563       {
18564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18565       };
18566     } catch (std::exception& e) {
18567       {
18568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18569       };
18570     } catch (...) {
18571       {
18572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18573       };
18574     }
18575   }
18576 }
18577
18578
18579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18580   void * jresult ;
18581   Dali::TypeInfo *arg1 = 0 ;
18582   Dali::TypeInfo *result = 0 ;
18583
18584   arg1 = (Dali::TypeInfo *)jarg1;
18585   if (!arg1) {
18586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18587     return 0;
18588   }
18589   {
18590     try {
18591       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18592     } catch (std::out_of_range& e) {
18593       {
18594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18595       };
18596     } catch (std::exception& e) {
18597       {
18598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18599       };
18600     } catch (...) {
18601       {
18602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18603       };
18604     }
18605   }
18606   jresult = (void *)result;
18607   return jresult;
18608 }
18609
18610
18611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18612   void * jresult ;
18613   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18614   Dali::TypeInfo *arg2 = 0 ;
18615   Dali::TypeInfo *result = 0 ;
18616
18617   arg1 = (Dali::TypeInfo *)jarg1;
18618   arg2 = (Dali::TypeInfo *)jarg2;
18619   if (!arg2) {
18620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18621     return 0;
18622   }
18623   {
18624     try {
18625       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18626     } catch (std::out_of_range& e) {
18627       {
18628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18629       };
18630     } catch (std::exception& e) {
18631       {
18632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18633       };
18634     } catch (...) {
18635       {
18636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18637       };
18638     }
18639   }
18640   jresult = (void *)result;
18641   return jresult;
18642 }
18643
18644
18645 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18646   char * jresult ;
18647   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18648   std::string *result = 0 ;
18649
18650   arg1 = (Dali::TypeInfo *)jarg1;
18651   {
18652     try {
18653       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18654     } catch (std::out_of_range& e) {
18655       {
18656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18657       };
18658     } catch (std::exception& e) {
18659       {
18660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18661       };
18662     } catch (...) {
18663       {
18664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18665       };
18666     }
18667   }
18668   jresult = SWIG_csharp_string_callback(result->c_str());
18669   return jresult;
18670 }
18671
18672
18673 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18674   char * jresult ;
18675   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18676   std::string *result = 0 ;
18677
18678   arg1 = (Dali::TypeInfo *)jarg1;
18679   {
18680     try {
18681       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18682     } catch (std::out_of_range& e) {
18683       {
18684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18685       };
18686     } catch (std::exception& e) {
18687       {
18688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18689       };
18690     } catch (...) {
18691       {
18692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18693       };
18694     }
18695   }
18696   jresult = SWIG_csharp_string_callback(result->c_str());
18697   return jresult;
18698 }
18699
18700
18701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18702   void * jresult ;
18703   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18704   Dali::BaseHandle result;
18705
18706   arg1 = (Dali::TypeInfo *)jarg1;
18707   {
18708     try {
18709       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18710     } catch (std::out_of_range& e) {
18711       {
18712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18713       };
18714     } catch (std::exception& e) {
18715       {
18716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18717       };
18718     } catch (...) {
18719       {
18720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18721       };
18722     }
18723   }
18724   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18725   return jresult;
18726 }
18727
18728
18729 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18730   unsigned long jresult ;
18731   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18732   size_t result;
18733
18734   arg1 = (Dali::TypeInfo *)jarg1;
18735   {
18736     try {
18737       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18738     } catch (std::out_of_range& e) {
18739       {
18740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18741       };
18742     } catch (std::exception& e) {
18743       {
18744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18745       };
18746     } catch (...) {
18747       {
18748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18749       };
18750     }
18751   }
18752   jresult = (unsigned long)result;
18753   return jresult;
18754 }
18755
18756
18757 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18758   char * jresult ;
18759   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18760   size_t arg2 ;
18761   std::string result;
18762
18763   arg1 = (Dali::TypeInfo *)jarg1;
18764   arg2 = (size_t)jarg2;
18765   {
18766     try {
18767       result = (arg1)->GetActionName(arg2);
18768     } catch (std::out_of_range& e) {
18769       {
18770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18771       };
18772     } catch (std::exception& e) {
18773       {
18774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18775       };
18776     } catch (...) {
18777       {
18778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18779       };
18780     }
18781   }
18782   jresult = SWIG_csharp_string_callback((&result)->c_str());
18783   return jresult;
18784 }
18785
18786
18787 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18788   unsigned long jresult ;
18789   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18790   size_t result;
18791
18792   arg1 = (Dali::TypeInfo *)jarg1;
18793   {
18794     try {
18795       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18796     } catch (std::out_of_range& e) {
18797       {
18798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18799       };
18800     } catch (std::exception& e) {
18801       {
18802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18803       };
18804     } catch (...) {
18805       {
18806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18807       };
18808     }
18809   }
18810   jresult = (unsigned long)result;
18811   return jresult;
18812 }
18813
18814
18815 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18816   char * jresult ;
18817   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18818   size_t arg2 ;
18819   std::string result;
18820
18821   arg1 = (Dali::TypeInfo *)jarg1;
18822   arg2 = (size_t)jarg2;
18823   {
18824     try {
18825       result = (arg1)->GetSignalName(arg2);
18826     } catch (std::out_of_range& e) {
18827       {
18828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18829       };
18830     } catch (std::exception& e) {
18831       {
18832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18833       };
18834     } catch (...) {
18835       {
18836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18837       };
18838     }
18839   }
18840   jresult = SWIG_csharp_string_callback((&result)->c_str());
18841   return jresult;
18842 }
18843
18844
18845 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18846   unsigned long jresult ;
18847   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18848   size_t result;
18849
18850   arg1 = (Dali::TypeInfo *)jarg1;
18851   {
18852     try {
18853       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18854     } catch (std::out_of_range& e) {
18855       {
18856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18857       };
18858     } catch (std::exception& e) {
18859       {
18860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18861       };
18862     } catch (...) {
18863       {
18864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18865       };
18866     }
18867   }
18868   jresult = (unsigned long)result;
18869   return jresult;
18870 }
18871
18872
18873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18874   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18875   Dali::Property::IndexContainer *arg2 = 0 ;
18876
18877   arg1 = (Dali::TypeInfo *)jarg1;
18878   arg2 = (Dali::Property::IndexContainer *)jarg2;
18879   if (!arg2) {
18880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18881     return ;
18882   }
18883   {
18884     try {
18885       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18886     } catch (std::out_of_range& e) {
18887       {
18888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18889       };
18890     } catch (std::exception& e) {
18891       {
18892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18893       };
18894     } catch (...) {
18895       {
18896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18897       };
18898     }
18899   }
18900 }
18901
18902
18903 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18904   char * jresult ;
18905   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18906   Dali::Property::Index arg2 ;
18907   std::string *result = 0 ;
18908
18909   arg1 = (Dali::TypeInfo *)jarg1;
18910   arg2 = (Dali::Property::Index)jarg2;
18911   {
18912     try {
18913       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18914     } catch (std::out_of_range& e) {
18915       {
18916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18917       };
18918     } catch (std::exception& e) {
18919       {
18920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18921       };
18922     } catch (...) {
18923       {
18924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18925       };
18926     }
18927   }
18928   jresult = SWIG_csharp_string_callback(result->c_str());
18929   return jresult;
18930 }
18931
18932
18933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18934   void * jresult ;
18935   Dali::TypeRegistry result;
18936
18937   {
18938     try {
18939       result = Dali::TypeRegistry::Get();
18940     } catch (std::out_of_range& e) {
18941       {
18942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18943       };
18944     } catch (std::exception& e) {
18945       {
18946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18947       };
18948     } catch (...) {
18949       {
18950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18951       };
18952     }
18953   }
18954   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18955   return jresult;
18956 }
18957
18958
18959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18960   void * jresult ;
18961   Dali::TypeRegistry *result = 0 ;
18962
18963   {
18964     try {
18965       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18966     } catch (std::out_of_range& e) {
18967       {
18968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18969       };
18970     } catch (std::exception& e) {
18971       {
18972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18973       };
18974     } catch (...) {
18975       {
18976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18977       };
18978     }
18979   }
18980   jresult = (void *)result;
18981   return jresult;
18982 }
18983
18984
18985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
18986   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
18987
18988   arg1 = (Dali::TypeRegistry *)jarg1;
18989   {
18990     try {
18991       delete arg1;
18992     } catch (std::out_of_range& e) {
18993       {
18994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18995       };
18996     } catch (std::exception& e) {
18997       {
18998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18999       };
19000     } catch (...) {
19001       {
19002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19003       };
19004     }
19005   }
19006 }
19007
19008
19009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19010   void * jresult ;
19011   Dali::TypeRegistry *arg1 = 0 ;
19012   Dali::TypeRegistry *result = 0 ;
19013
19014   arg1 = (Dali::TypeRegistry *)jarg1;
19015   if (!arg1) {
19016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19017     return 0;
19018   }
19019   {
19020     try {
19021       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19022     } catch (std::out_of_range& e) {
19023       {
19024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19025       };
19026     } catch (std::exception& e) {
19027       {
19028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19029       };
19030     } catch (...) {
19031       {
19032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19033       };
19034     }
19035   }
19036   jresult = (void *)result;
19037   return jresult;
19038 }
19039
19040
19041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19042   void * jresult ;
19043   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19044   Dali::TypeRegistry *arg2 = 0 ;
19045   Dali::TypeRegistry *result = 0 ;
19046
19047   arg1 = (Dali::TypeRegistry *)jarg1;
19048   arg2 = (Dali::TypeRegistry *)jarg2;
19049   if (!arg2) {
19050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19051     return 0;
19052   }
19053   {
19054     try {
19055       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19056     } catch (std::out_of_range& e) {
19057       {
19058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19059       };
19060     } catch (std::exception& e) {
19061       {
19062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19063       };
19064     } catch (...) {
19065       {
19066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19067       };
19068     }
19069   }
19070   jresult = (void *)result;
19071   return jresult;
19072 }
19073
19074
19075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19076   void * jresult ;
19077   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19078   std::string *arg2 = 0 ;
19079   Dali::TypeInfo result;
19080
19081   arg1 = (Dali::TypeRegistry *)jarg1;
19082   if (!jarg2) {
19083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19084     return 0;
19085   }
19086   std::string arg2_str(jarg2);
19087   arg2 = &arg2_str;
19088   {
19089     try {
19090       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19091     } catch (std::out_of_range& e) {
19092       {
19093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19094       };
19095     } catch (std::exception& e) {
19096       {
19097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19098       };
19099     } catch (...) {
19100       {
19101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19102       };
19103     }
19104   }
19105   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19106
19107   //argout typemap for const std::string&
19108
19109   return jresult;
19110 }
19111
19112
19113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19114   void * jresult ;
19115   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19116   std::type_info *arg2 = 0 ;
19117   Dali::TypeInfo result;
19118
19119   arg1 = (Dali::TypeRegistry *)jarg1;
19120   arg2 = (std::type_info *)jarg2;
19121   if (!arg2) {
19122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19123     return 0;
19124   }
19125   {
19126     try {
19127       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19128     } catch (std::out_of_range& e) {
19129       {
19130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19131       };
19132     } catch (std::exception& e) {
19133       {
19134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19135       };
19136     } catch (...) {
19137       {
19138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19139       };
19140     }
19141   }
19142   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19143   return jresult;
19144 }
19145
19146
19147 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19148   unsigned long jresult ;
19149   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19150   size_t result;
19151
19152   arg1 = (Dali::TypeRegistry *)jarg1;
19153   {
19154     try {
19155       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19156     } catch (std::out_of_range& e) {
19157       {
19158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19159       };
19160     } catch (std::exception& e) {
19161       {
19162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (...) {
19165       {
19166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19167       };
19168     }
19169   }
19170   jresult = (unsigned long)result;
19171   return jresult;
19172 }
19173
19174
19175 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19176   char * jresult ;
19177   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19178   size_t arg2 ;
19179   std::string result;
19180
19181   arg1 = (Dali::TypeRegistry *)jarg1;
19182   arg2 = (size_t)jarg2;
19183   {
19184     try {
19185       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19186     } catch (std::out_of_range& e) {
19187       {
19188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19189       };
19190     } catch (std::exception& e) {
19191       {
19192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19193       };
19194     } catch (...) {
19195       {
19196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19197       };
19198     }
19199   }
19200   jresult = SWIG_csharp_string_callback((&result)->c_str());
19201   return jresult;
19202 }
19203
19204
19205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19206   void * jresult ;
19207   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19208   Dali::TypeRegistry *result = 0 ;
19209
19210   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19211   {
19212     try {
19213       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19214     } catch (std::out_of_range& e) {
19215       {
19216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19217       };
19218     } catch (std::exception& e) {
19219       {
19220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19221       };
19222     } catch (...) {
19223       {
19224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19225       };
19226     }
19227   }
19228   jresult = (void *)result;
19229   return jresult;
19230 }
19231
19232
19233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19234   void * jresult ;
19235   std::type_info *arg1 = 0 ;
19236   std::type_info *arg2 = 0 ;
19237   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19238   Dali::TypeRegistration *result = 0 ;
19239
19240   arg1 = (std::type_info *)jarg1;
19241   if (!arg1) {
19242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19243     return 0;
19244   }
19245   arg2 = (std::type_info *)jarg2;
19246   if (!arg2) {
19247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19248     return 0;
19249   }
19250   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19251   {
19252     try {
19253       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19254     } catch (std::out_of_range& e) {
19255       {
19256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19257       };
19258     } catch (std::exception& e) {
19259       {
19260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19261       };
19262     } catch (...) {
19263       {
19264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19265       };
19266     }
19267   }
19268   jresult = (void *)result;
19269   return jresult;
19270 }
19271
19272
19273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19274   void * jresult ;
19275   std::type_info *arg1 = 0 ;
19276   std::type_info *arg2 = 0 ;
19277   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19278   bool arg4 ;
19279   Dali::TypeRegistration *result = 0 ;
19280
19281   arg1 = (std::type_info *)jarg1;
19282   if (!arg1) {
19283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19284     return 0;
19285   }
19286   arg2 = (std::type_info *)jarg2;
19287   if (!arg2) {
19288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19289     return 0;
19290   }
19291   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19292   arg4 = jarg4 ? true : false;
19293   {
19294     try {
19295       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19296     } catch (std::out_of_range& e) {
19297       {
19298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19299       };
19300     } catch (std::exception& e) {
19301       {
19302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19303       };
19304     } catch (...) {
19305       {
19306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19307       };
19308     }
19309   }
19310   jresult = (void *)result;
19311   return jresult;
19312 }
19313
19314
19315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19316   void * jresult ;
19317   std::string *arg1 = 0 ;
19318   std::type_info *arg2 = 0 ;
19319   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19320   Dali::TypeRegistration *result = 0 ;
19321
19322   if (!jarg1) {
19323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19324     return 0;
19325   }
19326   std::string arg1_str(jarg1);
19327   arg1 = &arg1_str;
19328   arg2 = (std::type_info *)jarg2;
19329   if (!arg2) {
19330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19331     return 0;
19332   }
19333   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19334   {
19335     try {
19336       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19337     } catch (std::out_of_range& e) {
19338       {
19339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19340       };
19341     } catch (std::exception& e) {
19342       {
19343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19344       };
19345     } catch (...) {
19346       {
19347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19348       };
19349     }
19350   }
19351   jresult = (void *)result;
19352
19353   //argout typemap for const std::string&
19354
19355   return jresult;
19356 }
19357
19358
19359 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19360   char * jresult ;
19361   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19362   std::string result;
19363
19364   arg1 = (Dali::TypeRegistration *)jarg1;
19365   {
19366     try {
19367       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19368     } catch (std::out_of_range& e) {
19369       {
19370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19371       };
19372     } catch (std::exception& e) {
19373       {
19374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19375       };
19376     } catch (...) {
19377       {
19378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19379       };
19380     }
19381   }
19382   jresult = SWIG_csharp_string_callback((&result)->c_str());
19383   return jresult;
19384 }
19385
19386
19387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19388   std::string *arg1 = 0 ;
19389   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19390
19391   if (!jarg1) {
19392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19393     return ;
19394   }
19395   std::string arg1_str(jarg1);
19396   arg1 = &arg1_str;
19397   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19398   {
19399     try {
19400       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19401     } catch (std::out_of_range& e) {
19402       {
19403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19404       };
19405     } catch (std::exception& e) {
19406       {
19407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19408       };
19409     } catch (...) {
19410       {
19411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19412       };
19413     }
19414   }
19415
19416   //argout typemap for const std::string&
19417
19418 }
19419
19420
19421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19422   std::string *arg1 = 0 ;
19423   std::string *arg2 = 0 ;
19424   int arg3 ;
19425   Dali::Property::Type arg4 ;
19426   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19427   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19428
19429   if (!jarg1) {
19430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19431     return ;
19432   }
19433   std::string arg1_str(jarg1);
19434   arg1 = &arg1_str;
19435   if (!jarg2) {
19436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19437     return ;
19438   }
19439   std::string arg2_str(jarg2);
19440   arg2 = &arg2_str;
19441   arg3 = (int)jarg3;
19442   arg4 = (Dali::Property::Type)jarg4;
19443   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19444   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19445   {
19446     try {
19447       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19448     } catch (std::out_of_range& e) {
19449       {
19450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19451       };
19452     } catch (std::exception& e) {
19453       {
19454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19455       };
19456     } catch (...) {
19457       {
19458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19459       };
19460     }
19461   }
19462
19463   //argout typemap for const std::string&
19464
19465
19466   //argout typemap for const std::string&
19467
19468 }
19469
19470
19471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19472   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19473
19474   arg1 = (Dali::TypeRegistration *)jarg1;
19475   {
19476     try {
19477       delete arg1;
19478     } catch (std::out_of_range& e) {
19479       {
19480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19481       };
19482     } catch (std::exception& e) {
19483       {
19484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19485       };
19486     } catch (...) {
19487       {
19488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19489       };
19490     }
19491   }
19492 }
19493
19494
19495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19496   void * jresult ;
19497   Dali::TypeRegistration *arg1 = 0 ;
19498   std::string *arg2 = 0 ;
19499   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19500   Dali::SignalConnectorType *result = 0 ;
19501
19502   arg1 = (Dali::TypeRegistration *)jarg1;
19503   if (!arg1) {
19504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19505     return 0;
19506   }
19507   if (!jarg2) {
19508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19509     return 0;
19510   }
19511   std::string arg2_str(jarg2);
19512   arg2 = &arg2_str;
19513   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19514   {
19515     try {
19516       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19517     } catch (std::out_of_range& e) {
19518       {
19519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19520       };
19521     } catch (std::exception& e) {
19522       {
19523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19524       };
19525     } catch (...) {
19526       {
19527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19528       };
19529     }
19530   }
19531   jresult = (void *)result;
19532
19533   //argout typemap for const std::string&
19534
19535   return jresult;
19536 }
19537
19538
19539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19540   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19541
19542   arg1 = (Dali::SignalConnectorType *)jarg1;
19543   {
19544     try {
19545       delete arg1;
19546     } catch (std::out_of_range& e) {
19547       {
19548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19549       };
19550     } catch (std::exception& e) {
19551       {
19552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19553       };
19554     } catch (...) {
19555       {
19556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19557       };
19558     }
19559   }
19560 }
19561
19562
19563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19564   void * jresult ;
19565   Dali::TypeRegistration *arg1 = 0 ;
19566   std::string *arg2 = 0 ;
19567   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19568   Dali::TypeAction *result = 0 ;
19569
19570   arg1 = (Dali::TypeRegistration *)jarg1;
19571   if (!arg1) {
19572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19573     return 0;
19574   }
19575   if (!jarg2) {
19576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19577     return 0;
19578   }
19579   std::string arg2_str(jarg2);
19580   arg2 = &arg2_str;
19581   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19582   {
19583     try {
19584       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19585     } catch (std::out_of_range& e) {
19586       {
19587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19588       };
19589     } catch (std::exception& e) {
19590       {
19591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19592       };
19593     } catch (...) {
19594       {
19595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19596       };
19597     }
19598   }
19599   jresult = (void *)result;
19600
19601   //argout typemap for const std::string&
19602
19603   return jresult;
19604 }
19605
19606
19607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19608   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19609
19610   arg1 = (Dali::TypeAction *)jarg1;
19611   {
19612     try {
19613       delete arg1;
19614     } catch (std::out_of_range& e) {
19615       {
19616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19617       };
19618     } catch (std::exception& e) {
19619       {
19620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19621       };
19622     } catch (...) {
19623       {
19624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19625       };
19626     }
19627   }
19628 }
19629
19630
19631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19632   void * jresult ;
19633   Dali::TypeRegistration *arg1 = 0 ;
19634   std::string *arg2 = 0 ;
19635   Dali::Property::Index arg3 ;
19636   Dali::Property::Type arg4 ;
19637   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19638   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19639   Dali::PropertyRegistration *result = 0 ;
19640
19641   arg1 = (Dali::TypeRegistration *)jarg1;
19642   if (!arg1) {
19643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19644     return 0;
19645   }
19646   if (!jarg2) {
19647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19648     return 0;
19649   }
19650   std::string arg2_str(jarg2);
19651   arg2 = &arg2_str;
19652   arg3 = (Dali::Property::Index)jarg3;
19653   arg4 = (Dali::Property::Type)jarg4;
19654   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19655   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19656   {
19657     try {
19658       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19659     } catch (std::out_of_range& e) {
19660       {
19661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19662       };
19663     } catch (std::exception& e) {
19664       {
19665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19666       };
19667     } catch (...) {
19668       {
19669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19670       };
19671     }
19672   }
19673   jresult = (void *)result;
19674
19675   //argout typemap for const std::string&
19676
19677   return jresult;
19678 }
19679
19680
19681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19682   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19683
19684   arg1 = (Dali::PropertyRegistration *)jarg1;
19685   {
19686     try {
19687       delete arg1;
19688     } catch (std::out_of_range& e) {
19689       {
19690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19691       };
19692     } catch (std::exception& e) {
19693       {
19694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19695       };
19696     } catch (...) {
19697       {
19698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19699       };
19700     }
19701   }
19702 }
19703
19704
19705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19706   void * jresult ;
19707   Dali::TypeRegistration *arg1 = 0 ;
19708   std::string *arg2 = 0 ;
19709   Dali::Property::Index arg3 ;
19710   Dali::Property::Type arg4 ;
19711   Dali::AnimatablePropertyRegistration *result = 0 ;
19712
19713   arg1 = (Dali::TypeRegistration *)jarg1;
19714   if (!arg1) {
19715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19716     return 0;
19717   }
19718   if (!jarg2) {
19719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19720     return 0;
19721   }
19722   std::string arg2_str(jarg2);
19723   arg2 = &arg2_str;
19724   arg3 = (Dali::Property::Index)jarg3;
19725   arg4 = (Dali::Property::Type)jarg4;
19726   {
19727     try {
19728       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19729     } catch (std::out_of_range& e) {
19730       {
19731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19732       };
19733     } catch (std::exception& e) {
19734       {
19735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19736       };
19737     } catch (...) {
19738       {
19739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19740       };
19741     }
19742   }
19743   jresult = (void *)result;
19744
19745   //argout typemap for const std::string&
19746
19747   return jresult;
19748 }
19749
19750
19751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19752   void * jresult ;
19753   Dali::TypeRegistration *arg1 = 0 ;
19754   std::string *arg2 = 0 ;
19755   Dali::Property::Index arg3 ;
19756   Dali::Property::Value *arg4 = 0 ;
19757   Dali::AnimatablePropertyRegistration *result = 0 ;
19758
19759   arg1 = (Dali::TypeRegistration *)jarg1;
19760   if (!arg1) {
19761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19762     return 0;
19763   }
19764   if (!jarg2) {
19765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19766     return 0;
19767   }
19768   std::string arg2_str(jarg2);
19769   arg2 = &arg2_str;
19770   arg3 = (Dali::Property::Index)jarg3;
19771   arg4 = (Dali::Property::Value *)jarg4;
19772   if (!arg4) {
19773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19774     return 0;
19775   }
19776   {
19777     try {
19778       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19779     } catch (std::out_of_range& e) {
19780       {
19781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19782       };
19783     } catch (std::exception& e) {
19784       {
19785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19786       };
19787     } catch (...) {
19788       {
19789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19790       };
19791     }
19792   }
19793   jresult = (void *)result;
19794
19795   //argout typemap for const std::string&
19796
19797   return jresult;
19798 }
19799
19800
19801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19802   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19803
19804   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19805   {
19806     try {
19807       delete arg1;
19808     } catch (std::out_of_range& e) {
19809       {
19810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19811       };
19812     } catch (std::exception& e) {
19813       {
19814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19815       };
19816     } catch (...) {
19817       {
19818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19819       };
19820     }
19821   }
19822 }
19823
19824
19825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19826   void * jresult ;
19827   Dali::TypeRegistration *arg1 = 0 ;
19828   std::string *arg2 = 0 ;
19829   Dali::Property::Index arg3 ;
19830   Dali::Property::Index arg4 ;
19831   unsigned int arg5 ;
19832   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19833
19834   arg1 = (Dali::TypeRegistration *)jarg1;
19835   if (!arg1) {
19836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19837     return 0;
19838   }
19839   if (!jarg2) {
19840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19841     return 0;
19842   }
19843   std::string arg2_str(jarg2);
19844   arg2 = &arg2_str;
19845   arg3 = (Dali::Property::Index)jarg3;
19846   arg4 = (Dali::Property::Index)jarg4;
19847   arg5 = (unsigned int)jarg5;
19848   {
19849     try {
19850       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19851     } catch (std::out_of_range& e) {
19852       {
19853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19854       };
19855     } catch (std::exception& e) {
19856       {
19857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19858       };
19859     } catch (...) {
19860       {
19861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19862       };
19863     }
19864   }
19865   jresult = (void *)result;
19866
19867   //argout typemap for const std::string&
19868
19869   return jresult;
19870 }
19871
19872
19873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19874   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19875
19876   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19877   {
19878     try {
19879       delete arg1;
19880     } catch (std::out_of_range& e) {
19881       {
19882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19883       };
19884     } catch (std::exception& e) {
19885       {
19886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19887       };
19888     } catch (...) {
19889       {
19890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19891       };
19892     }
19893   }
19894 }
19895
19896
19897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19898   void * jresult ;
19899   Dali::TypeRegistration *arg1 = 0 ;
19900   std::string *arg2 = 0 ;
19901   Dali::Property::Index arg3 ;
19902   Dali::Property::Type arg4 ;
19903   Dali::ChildPropertyRegistration *result = 0 ;
19904
19905   arg1 = (Dali::TypeRegistration *)jarg1;
19906   if (!arg1) {
19907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19908     return 0;
19909   }
19910   if (!jarg2) {
19911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19912     return 0;
19913   }
19914   std::string arg2_str(jarg2);
19915   arg2 = &arg2_str;
19916   arg3 = (Dali::Property::Index)jarg3;
19917   arg4 = (Dali::Property::Type)jarg4;
19918   {
19919     try {
19920       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19921     } catch (std::out_of_range& e) {
19922       {
19923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19924       };
19925     } catch (std::exception& e) {
19926       {
19927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19928       };
19929     } catch (...) {
19930       {
19931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19932       };
19933     }
19934   }
19935   jresult = (void *)result;
19936
19937   //argout typemap for const std::string&
19938
19939   return jresult;
19940 }
19941
19942
19943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19944   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19945
19946   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19947   {
19948     try {
19949       delete arg1;
19950     } catch (std::out_of_range& e) {
19951       {
19952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19953       };
19954     } catch (std::exception& e) {
19955       {
19956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19957       };
19958     } catch (...) {
19959       {
19960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19961       };
19962     }
19963   }
19964 }
19965
19966
19967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19968   unsigned int jresult ;
19969   std::string *arg1 = 0 ;
19970   std::type_info *arg2 = 0 ;
19971   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19972   bool result;
19973
19974   if (!jarg1) {
19975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19976     return 0;
19977   }
19978   std::string arg1_str(jarg1);
19979   arg1 = &arg1_str;
19980   arg2 = (std::type_info *)jarg2;
19981   if (!arg2) {
19982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19983     return 0;
19984   }
19985   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
19986   {
19987     try {
19988       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19989     } catch (std::out_of_range& e) {
19990       {
19991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19992       };
19993     } catch (std::exception& e) {
19994       {
19995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19996       };
19997     } catch (...) {
19998       {
19999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20000       };
20001     }
20002   }
20003   jresult = result;
20004
20005   //argout typemap for const std::string&
20006
20007   return jresult;
20008 }
20009
20010
20011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20012   unsigned int jresult ;
20013   std::string *arg1 = 0 ;
20014   std::string *arg2 = 0 ;
20015   Dali::Property::Index arg3 ;
20016   Dali::Property::Type arg4 ;
20017   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20018   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20019   bool result;
20020
20021   if (!jarg1) {
20022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20023     return 0;
20024   }
20025   std::string arg1_str(jarg1);
20026   arg1 = &arg1_str;
20027   if (!jarg2) {
20028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20029     return 0;
20030   }
20031   std::string arg2_str(jarg2);
20032   arg2 = &arg2_str;
20033   arg3 = (Dali::Property::Index)jarg3;
20034   arg4 = (Dali::Property::Type)jarg4;
20035   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20036   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20037   {
20038     try {
20039       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20040     } catch (std::out_of_range& e) {
20041       {
20042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20043       };
20044     } catch (std::exception& e) {
20045       {
20046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20047       };
20048     } catch (...) {
20049       {
20050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20051       };
20052     }
20053   }
20054   jresult = result;
20055
20056   //argout typemap for const std::string&
20057
20058
20059   //argout typemap for const std::string&
20060
20061   return jresult;
20062 }
20063
20064
20065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20066   float jresult ;
20067   float result;
20068
20069   result = (float)(float)Dali::ParentOrigin::TOP;
20070   jresult = result;
20071   return jresult;
20072 }
20073
20074
20075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20076   float jresult ;
20077   float result;
20078
20079   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20080   jresult = result;
20081   return jresult;
20082 }
20083
20084
20085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20086   float jresult ;
20087   float result;
20088
20089   result = (float)(float)Dali::ParentOrigin::LEFT;
20090   jresult = result;
20091   return jresult;
20092 }
20093
20094
20095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20096   float jresult ;
20097   float result;
20098
20099   result = (float)(float)Dali::ParentOrigin::RIGHT;
20100   jresult = result;
20101   return jresult;
20102 }
20103
20104
20105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20106   float jresult ;
20107   float result;
20108
20109   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20110   jresult = result;
20111   return jresult;
20112 }
20113
20114
20115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20116   void * jresult ;
20117   Dali::Vector3 *result = 0 ;
20118
20119   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20120   jresult = (void *)result;
20121   return jresult;
20122 }
20123
20124
20125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20126   void * jresult ;
20127   Dali::Vector3 *result = 0 ;
20128
20129   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20130   jresult = (void *)result;
20131   return jresult;
20132 }
20133
20134
20135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20136   void * jresult ;
20137   Dali::Vector3 *result = 0 ;
20138
20139   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20140   jresult = (void *)result;
20141   return jresult;
20142 }
20143
20144
20145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20146   void * jresult ;
20147   Dali::Vector3 *result = 0 ;
20148
20149   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20150   jresult = (void *)result;
20151   return jresult;
20152 }
20153
20154
20155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20156   void * jresult ;
20157   Dali::Vector3 *result = 0 ;
20158
20159   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20160   jresult = (void *)result;
20161   return jresult;
20162 }
20163
20164
20165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20166   void * jresult ;
20167   Dali::Vector3 *result = 0 ;
20168
20169   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20170   jresult = (void *)result;
20171   return jresult;
20172 }
20173
20174
20175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20176   void * jresult ;
20177   Dali::Vector3 *result = 0 ;
20178
20179   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20180   jresult = (void *)result;
20181   return jresult;
20182 }
20183
20184
20185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20186   void * jresult ;
20187   Dali::Vector3 *result = 0 ;
20188
20189   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20190   jresult = (void *)result;
20191   return jresult;
20192 }
20193
20194
20195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20196   void * jresult ;
20197   Dali::Vector3 *result = 0 ;
20198
20199   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20200   jresult = (void *)result;
20201   return jresult;
20202 }
20203
20204
20205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20206   float jresult ;
20207   float result;
20208
20209   result = (float)(float)Dali::AnchorPoint::TOP;
20210   jresult = result;
20211   return jresult;
20212 }
20213
20214
20215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20216   float jresult ;
20217   float result;
20218
20219   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20220   jresult = result;
20221   return jresult;
20222 }
20223
20224
20225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20226   float jresult ;
20227   float result;
20228
20229   result = (float)(float)Dali::AnchorPoint::LEFT;
20230   jresult = result;
20231   return jresult;
20232 }
20233
20234
20235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20236   float jresult ;
20237   float result;
20238
20239   result = (float)(float)Dali::AnchorPoint::RIGHT;
20240   jresult = result;
20241   return jresult;
20242 }
20243
20244
20245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20246   float jresult ;
20247   float result;
20248
20249   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20250   jresult = result;
20251   return jresult;
20252 }
20253
20254
20255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20256   void * jresult ;
20257   Dali::Vector3 *result = 0 ;
20258
20259   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20260   jresult = (void *)result;
20261   return jresult;
20262 }
20263
20264
20265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20266   void * jresult ;
20267   Dali::Vector3 *result = 0 ;
20268
20269   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20270   jresult = (void *)result;
20271   return jresult;
20272 }
20273
20274
20275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20276   void * jresult ;
20277   Dali::Vector3 *result = 0 ;
20278
20279   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20280   jresult = (void *)result;
20281   return jresult;
20282 }
20283
20284
20285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20286   void * jresult ;
20287   Dali::Vector3 *result = 0 ;
20288
20289   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20290   jresult = (void *)result;
20291   return jresult;
20292 }
20293
20294
20295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20296   void * jresult ;
20297   Dali::Vector3 *result = 0 ;
20298
20299   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20300   jresult = (void *)result;
20301   return jresult;
20302 }
20303
20304
20305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20306   void * jresult ;
20307   Dali::Vector3 *result = 0 ;
20308
20309   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20310   jresult = (void *)result;
20311   return jresult;
20312 }
20313
20314
20315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20316   void * jresult ;
20317   Dali::Vector3 *result = 0 ;
20318
20319   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20320   jresult = (void *)result;
20321   return jresult;
20322 }
20323
20324
20325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20326   void * jresult ;
20327   Dali::Vector3 *result = 0 ;
20328
20329   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20330   jresult = (void *)result;
20331   return jresult;
20332 }
20333
20334
20335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20336   void * jresult ;
20337   Dali::Vector3 *result = 0 ;
20338
20339   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20340   jresult = (void *)result;
20341   return jresult;
20342 }
20343
20344
20345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20346   void * jresult ;
20347   Dali::Vector4 *result = 0 ;
20348
20349   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20350   jresult = (void *)result;
20351   return jresult;
20352 }
20353
20354
20355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20356   void * jresult ;
20357   Dali::Vector4 *result = 0 ;
20358
20359   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20360   jresult = (void *)result;
20361   return jresult;
20362 }
20363
20364
20365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20366   void * jresult ;
20367   Dali::Vector4 *result = 0 ;
20368
20369   result = (Dali::Vector4 *)&Dali::Color::RED;
20370   jresult = (void *)result;
20371   return jresult;
20372 }
20373
20374
20375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20376   void * jresult ;
20377   Dali::Vector4 *result = 0 ;
20378
20379   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20380   jresult = (void *)result;
20381   return jresult;
20382 }
20383
20384
20385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20386   void * jresult ;
20387   Dali::Vector4 *result = 0 ;
20388
20389   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20390   jresult = (void *)result;
20391   return jresult;
20392 }
20393
20394
20395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20396   void * jresult ;
20397   Dali::Vector4 *result = 0 ;
20398
20399   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20400   jresult = (void *)result;
20401   return jresult;
20402 }
20403
20404
20405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20406   void * jresult ;
20407   Dali::Vector4 *result = 0 ;
20408
20409   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20410   jresult = (void *)result;
20411   return jresult;
20412 }
20413
20414
20415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20416   void * jresult ;
20417   Dali::Vector4 *result = 0 ;
20418
20419   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20420   jresult = (void *)result;
20421   return jresult;
20422 }
20423
20424
20425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20426   void * jresult ;
20427   Dali::Vector4 *result = 0 ;
20428
20429   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20430   jresult = (void *)result;
20431   return jresult;
20432 }
20433
20434
20435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20436   float jresult ;
20437   float result;
20438
20439   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20440   jresult = result;
20441   return jresult;
20442 }
20443
20444
20445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20446   float jresult ;
20447   float result;
20448
20449   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20450   jresult = result;
20451   return jresult;
20452 }
20453
20454
20455 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20456   float jresult ;
20457   float result;
20458
20459   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20460   jresult = result;
20461   return jresult;
20462 }
20463
20464
20465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20466   float jresult ;
20467   float result;
20468
20469   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20470   jresult = result;
20471   return jresult;
20472 }
20473
20474
20475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20476   float jresult ;
20477   float result;
20478
20479   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20480   jresult = result;
20481   return jresult;
20482 }
20483
20484
20485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20486   float jresult ;
20487   float result;
20488
20489   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20490   jresult = result;
20491   return jresult;
20492 }
20493
20494
20495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20496   float jresult ;
20497   float result;
20498
20499   result = (float)(float)Dali::Math::PI;
20500   jresult = result;
20501   return jresult;
20502 }
20503
20504
20505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20506   float jresult ;
20507   float result;
20508
20509   result = (float)(float)Dali::Math::PI_2;
20510   jresult = result;
20511   return jresult;
20512 }
20513
20514
20515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20516   float jresult ;
20517   float result;
20518
20519   result = (float)(float)Dali::Math::PI_4;
20520   jresult = result;
20521   return jresult;
20522 }
20523
20524
20525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20526   float jresult ;
20527   float result;
20528
20529   result = (float)(float)Dali::Math::PI_OVER_180;
20530   jresult = result;
20531   return jresult;
20532 }
20533
20534
20535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20536   float jresult ;
20537   float result;
20538
20539   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20540   jresult = result;
20541   return jresult;
20542 }
20543
20544
20545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20546   int jresult ;
20547   Dali::ResizePolicy::Type result;
20548
20549   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20550   jresult = (int)result;
20551   return jresult;
20552 }
20553
20554
20555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20556   unsigned long jresult ;
20557   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20558   Dali::VectorBase::SizeType result;
20559
20560   arg1 = (Dali::VectorBase *)jarg1;
20561   {
20562     try {
20563       result = ((Dali::VectorBase const *)arg1)->Count();
20564     } catch (std::out_of_range& e) {
20565       {
20566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20567       };
20568     } catch (std::exception& e) {
20569       {
20570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20571       };
20572     } catch (...) {
20573       {
20574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20575       };
20576     }
20577   }
20578   jresult = (unsigned long)result;
20579   return jresult;
20580 }
20581
20582
20583 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20584   unsigned long jresult ;
20585   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20586   Dali::VectorBase::SizeType result;
20587
20588   arg1 = (Dali::VectorBase *)jarg1;
20589   {
20590     try {
20591       result = ((Dali::VectorBase const *)arg1)->Size();
20592     } catch (std::out_of_range& e) {
20593       {
20594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20595       };
20596     } catch (std::exception& e) {
20597       {
20598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20599       };
20600     } catch (...) {
20601       {
20602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20603       };
20604     }
20605   }
20606   jresult = (unsigned long)result;
20607   return jresult;
20608 }
20609
20610
20611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20612   unsigned int jresult ;
20613   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20614   bool result;
20615
20616   arg1 = (Dali::VectorBase *)jarg1;
20617   {
20618     try {
20619       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20620     } catch (std::out_of_range& e) {
20621       {
20622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20623       };
20624     } catch (std::exception& e) {
20625       {
20626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20627       };
20628     } catch (...) {
20629       {
20630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20631       };
20632     }
20633   }
20634   jresult = result;
20635   return jresult;
20636 }
20637
20638
20639 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20640   unsigned long jresult ;
20641   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20642   Dali::VectorBase::SizeType result;
20643
20644   arg1 = (Dali::VectorBase *)jarg1;
20645   {
20646     try {
20647       result = ((Dali::VectorBase const *)arg1)->Capacity();
20648     } catch (std::out_of_range& e) {
20649       {
20650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20651       };
20652     } catch (std::exception& e) {
20653       {
20654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20655       };
20656     } catch (...) {
20657       {
20658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20659       };
20660     }
20661   }
20662   jresult = (unsigned long)result;
20663   return jresult;
20664 }
20665
20666
20667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20668   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20669
20670   arg1 = (Dali::VectorBase *)jarg1;
20671   {
20672     try {
20673       (arg1)->Release();
20674     } catch (std::out_of_range& e) {
20675       {
20676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20677       };
20678     } catch (std::exception& e) {
20679       {
20680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20681       };
20682     } catch (...) {
20683       {
20684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20685       };
20686     }
20687   }
20688 }
20689
20690
20691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20692   void * jresult ;
20693   Dali::Image *result = 0 ;
20694
20695   {
20696     try {
20697       result = (Dali::Image *)new Dali::Image();
20698     } catch (std::out_of_range& e) {
20699       {
20700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (std::exception& e) {
20703       {
20704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20705       };
20706     } catch (...) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20709       };
20710     }
20711   }
20712   jresult = (void *)result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20718   Dali::Image *arg1 = (Dali::Image *) 0 ;
20719
20720   arg1 = (Dali::Image *)jarg1;
20721   {
20722     try {
20723       delete arg1;
20724     } catch (std::out_of_range& e) {
20725       {
20726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20727       };
20728     } catch (std::exception& e) {
20729       {
20730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20731       };
20732     } catch (...) {
20733       {
20734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20735       };
20736     }
20737   }
20738 }
20739
20740
20741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20742   void * jresult ;
20743   Dali::Image *arg1 = 0 ;
20744   Dali::Image *result = 0 ;
20745
20746   arg1 = (Dali::Image *)jarg1;
20747   if (!arg1) {
20748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20749     return 0;
20750   }
20751   {
20752     try {
20753       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20754     } catch (std::out_of_range& e) {
20755       {
20756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20757       };
20758     } catch (std::exception& e) {
20759       {
20760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20761       };
20762     } catch (...) {
20763       {
20764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20765       };
20766     }
20767   }
20768   jresult = (void *)result;
20769   return jresult;
20770 }
20771
20772
20773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20774   void * jresult ;
20775   Dali::Image *arg1 = (Dali::Image *) 0 ;
20776   Dali::Image *arg2 = 0 ;
20777   Dali::Image *result = 0 ;
20778
20779   arg1 = (Dali::Image *)jarg1;
20780   arg2 = (Dali::Image *)jarg2;
20781   if (!arg2) {
20782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20783     return 0;
20784   }
20785   {
20786     try {
20787       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20788     } catch (std::out_of_range& e) {
20789       {
20790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20791       };
20792     } catch (std::exception& e) {
20793       {
20794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20795       };
20796     } catch (...) {
20797       {
20798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20799       };
20800     }
20801   }
20802   jresult = (void *)result;
20803   return jresult;
20804 }
20805
20806
20807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20808   void * jresult ;
20809   Dali::BaseHandle arg1 ;
20810   Dali::BaseHandle *argp1 ;
20811   Dali::Image result;
20812
20813   argp1 = (Dali::BaseHandle *)jarg1;
20814   if (!argp1) {
20815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20816     return 0;
20817   }
20818   arg1 = *argp1;
20819   {
20820     try {
20821       result = Dali::Image::DownCast(arg1);
20822     } catch (std::out_of_range& e) {
20823       {
20824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20825       };
20826     } catch (std::exception& e) {
20827       {
20828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20829       };
20830     } catch (...) {
20831       {
20832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20833       };
20834     }
20835   }
20836   jresult = new Dali::Image((const Dali::Image &)result);
20837   return jresult;
20838 }
20839
20840
20841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20842   unsigned int jresult ;
20843   Dali::Image *arg1 = (Dali::Image *) 0 ;
20844   unsigned int result;
20845
20846   arg1 = (Dali::Image *)jarg1;
20847   {
20848     try {
20849       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20850     } catch (std::out_of_range& e) {
20851       {
20852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20853       };
20854     } catch (std::exception& e) {
20855       {
20856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20857       };
20858     } catch (...) {
20859       {
20860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20861       };
20862     }
20863   }
20864   jresult = result;
20865   return jresult;
20866 }
20867
20868
20869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20870   unsigned int jresult ;
20871   Dali::Image *arg1 = (Dali::Image *) 0 ;
20872   unsigned int result;
20873
20874   arg1 = (Dali::Image *)jarg1;
20875   {
20876     try {
20877       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20878     } catch (std::out_of_range& e) {
20879       {
20880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20881       };
20882     } catch (std::exception& e) {
20883       {
20884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20885       };
20886     } catch (...) {
20887       {
20888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20889       };
20890     }
20891   }
20892   jresult = result;
20893   return jresult;
20894 }
20895
20896
20897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20898   void * jresult ;
20899   Dali::Image *arg1 = (Dali::Image *) 0 ;
20900   Dali::Image::ImageSignalType *result = 0 ;
20901
20902   arg1 = (Dali::Image *)jarg1;
20903   {
20904     try {
20905       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20906     } catch (std::out_of_range& e) {
20907       {
20908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20909       };
20910     } catch (std::exception& e) {
20911       {
20912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20917       };
20918     }
20919   }
20920   jresult = (void *)result;
20921   return jresult;
20922 }
20923
20924
20925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20926   int jresult ;
20927   Dali::Pixel::Format result;
20928
20929   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20930   jresult = (int)result;
20931   return jresult;
20932 }
20933
20934
20935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20936   int jresult ;
20937   Dali::Pixel::Format result;
20938
20939   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20940   jresult = (int)result;
20941   return jresult;
20942 }
20943
20944
20945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20946   unsigned int jresult ;
20947   Dali::Pixel::Format arg1 ;
20948   bool result;
20949
20950   arg1 = (Dali::Pixel::Format)jarg1;
20951   {
20952     try {
20953       result = (bool)Dali::Pixel::HasAlpha(arg1);
20954     } catch (std::out_of_range& e) {
20955       {
20956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20957       };
20958     } catch (std::exception& e) {
20959       {
20960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20961       };
20962     } catch (...) {
20963       {
20964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20965       };
20966     }
20967   }
20968   jresult = result;
20969   return jresult;
20970 }
20971
20972
20973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20974   unsigned int jresult ;
20975   Dali::Pixel::Format arg1 ;
20976   unsigned int result;
20977
20978   arg1 = (Dali::Pixel::Format)jarg1;
20979   {
20980     try {
20981       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20982     } catch (std::out_of_range& e) {
20983       {
20984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20985       };
20986     } catch (std::exception& e) {
20987       {
20988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20989       };
20990     } catch (...) {
20991       {
20992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20993       };
20994     }
20995   }
20996   jresult = result;
20997   return jresult;
20998 }
20999
21000
21001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21002   Dali::Pixel::Format arg1 ;
21003   int *arg2 = 0 ;
21004   int *arg3 = 0 ;
21005
21006   arg1 = (Dali::Pixel::Format)jarg1;
21007   arg2 = (int *)jarg2;
21008   if (!arg2) {
21009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21010     return ;
21011   }
21012   arg3 = (int *)jarg3;
21013   if (!arg3) {
21014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21015     return ;
21016   }
21017   {
21018     try {
21019       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21020     } catch (std::out_of_range& e) {
21021       {
21022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21023       };
21024     } catch (std::exception& e) {
21025       {
21026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21027       };
21028     } catch (...) {
21029       {
21030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21031       };
21032     }
21033   }
21034 }
21035
21036
21037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21038   void * jresult ;
21039   unsigned char *arg1 = (unsigned char *) 0 ;
21040   unsigned int arg2 ;
21041   unsigned int arg3 ;
21042   unsigned int arg4 ;
21043   Dali::Pixel::Format arg5 ;
21044   Dali::PixelData::ReleaseFunction arg6 ;
21045   Dali::PixelData result;
21046
21047   arg1 = jarg1;
21048   arg2 = (unsigned int)jarg2;
21049   arg3 = (unsigned int)jarg3;
21050   arg4 = (unsigned int)jarg4;
21051   arg5 = (Dali::Pixel::Format)jarg5;
21052   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21053   {
21054     try {
21055       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21056     } catch (std::out_of_range& e) {
21057       {
21058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21059       };
21060     } catch (std::exception& e) {
21061       {
21062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21063       };
21064     } catch (...) {
21065       {
21066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21067       };
21068     }
21069   }
21070   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21071
21072
21073   return jresult;
21074 }
21075
21076
21077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21078   void * jresult ;
21079   Dali::PixelData *result = 0 ;
21080
21081   {
21082     try {
21083       result = (Dali::PixelData *)new Dali::PixelData();
21084     } catch (std::out_of_range& e) {
21085       {
21086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21087       };
21088     } catch (std::exception& e) {
21089       {
21090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21091       };
21092     } catch (...) {
21093       {
21094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21095       };
21096     }
21097   }
21098   jresult = (void *)result;
21099   return jresult;
21100 }
21101
21102
21103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21104   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21105
21106   arg1 = (Dali::PixelData *)jarg1;
21107   {
21108     try {
21109       delete arg1;
21110     } catch (std::out_of_range& e) {
21111       {
21112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21113       };
21114     } catch (std::exception& e) {
21115       {
21116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21117       };
21118     } catch (...) {
21119       {
21120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21121       };
21122     }
21123   }
21124 }
21125
21126
21127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21128   void * jresult ;
21129   Dali::PixelData *arg1 = 0 ;
21130   Dali::PixelData *result = 0 ;
21131
21132   arg1 = (Dali::PixelData *)jarg1;
21133   if (!arg1) {
21134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21135     return 0;
21136   }
21137   {
21138     try {
21139       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21140     } catch (std::out_of_range& e) {
21141       {
21142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21143       };
21144     } catch (std::exception& e) {
21145       {
21146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21147       };
21148     } catch (...) {
21149       {
21150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21151       };
21152     }
21153   }
21154   jresult = (void *)result;
21155   return jresult;
21156 }
21157
21158
21159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21160   void * jresult ;
21161   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21162   Dali::PixelData *arg2 = 0 ;
21163   Dali::PixelData *result = 0 ;
21164
21165   arg1 = (Dali::PixelData *)jarg1;
21166   arg2 = (Dali::PixelData *)jarg2;
21167   if (!arg2) {
21168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21169     return 0;
21170   }
21171   {
21172     try {
21173       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21174     } catch (std::out_of_range& e) {
21175       {
21176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21177       };
21178     } catch (std::exception& e) {
21179       {
21180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21181       };
21182     } catch (...) {
21183       {
21184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21185       };
21186     }
21187   }
21188   jresult = (void *)result;
21189   return jresult;
21190 }
21191
21192
21193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21194   unsigned int jresult ;
21195   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21196   unsigned int result;
21197
21198   arg1 = (Dali::PixelData *)jarg1;
21199   {
21200     try {
21201       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21202     } catch (std::out_of_range& e) {
21203       {
21204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21205       };
21206     } catch (std::exception& e) {
21207       {
21208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21209       };
21210     } catch (...) {
21211       {
21212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21213       };
21214     }
21215   }
21216   jresult = result;
21217   return jresult;
21218 }
21219
21220
21221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21222   unsigned int jresult ;
21223   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21224   unsigned int result;
21225
21226   arg1 = (Dali::PixelData *)jarg1;
21227   {
21228     try {
21229       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21230     } catch (std::out_of_range& e) {
21231       {
21232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21233       };
21234     } catch (std::exception& e) {
21235       {
21236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21237       };
21238     } catch (...) {
21239       {
21240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21241       };
21242     }
21243   }
21244   jresult = result;
21245   return jresult;
21246 }
21247
21248
21249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21250   int jresult ;
21251   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21252   Dali::Pixel::Format result;
21253
21254   arg1 = (Dali::PixelData *)jarg1;
21255   {
21256     try {
21257       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21258     } catch (std::out_of_range& e) {
21259       {
21260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21261       };
21262     } catch (std::exception& e) {
21263       {
21264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21265       };
21266     } catch (...) {
21267       {
21268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21269       };
21270     }
21271   }
21272   jresult = (int)result;
21273   return jresult;
21274 }
21275
21276
21277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21278   unsigned int jresult ;
21279   unsigned int result;
21280
21281   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21282   jresult = result;
21283   return jresult;
21284 }
21285
21286
21287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21288   unsigned int jresult ;
21289   unsigned int result;
21290
21291   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21292   jresult = result;
21293   return jresult;
21294 }
21295
21296
21297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21298   unsigned int jresult ;
21299   unsigned int result;
21300
21301   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21302   jresult = result;
21303   return jresult;
21304 }
21305
21306
21307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21308   unsigned int jresult ;
21309   unsigned int result;
21310
21311   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21312   jresult = result;
21313   return jresult;
21314 }
21315
21316
21317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21318   unsigned int jresult ;
21319   unsigned int result;
21320
21321   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21322   jresult = result;
21323   return jresult;
21324 }
21325
21326
21327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21328   unsigned int jresult ;
21329   unsigned int result;
21330
21331   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21332   jresult = result;
21333   return jresult;
21334 }
21335
21336
21337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21338   void * jresult ;
21339   Dali::TextureType::Type arg1 ;
21340   Dali::Pixel::Format arg2 ;
21341   unsigned int arg3 ;
21342   unsigned int arg4 ;
21343   Dali::Texture result;
21344
21345   arg1 = (Dali::TextureType::Type)jarg1;
21346   arg2 = (Dali::Pixel::Format)jarg2;
21347   arg3 = (unsigned int)jarg3;
21348   arg4 = (unsigned int)jarg4;
21349   {
21350     try {
21351       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21352     } catch (std::out_of_range& e) {
21353       {
21354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21355       };
21356     } catch (std::exception& e) {
21357       {
21358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21359       };
21360     } catch (...) {
21361       {
21362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21363       };
21364     }
21365   }
21366   jresult = new Dali::Texture((const Dali::Texture &)result);
21367   return jresult;
21368 }
21369
21370
21371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21372   void * jresult ;
21373   NativeImageInterface *arg1 = 0 ;
21374   Dali::Texture result;
21375
21376   arg1 = (NativeImageInterface *)jarg1;
21377   if (!arg1) {
21378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21379     return 0;
21380   }
21381   {
21382     try {
21383       result = Dali::Texture::New(*arg1);
21384     } catch (std::out_of_range& e) {
21385       {
21386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21387       };
21388     } catch (std::exception& e) {
21389       {
21390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21391       };
21392     } catch (...) {
21393       {
21394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21395       };
21396     }
21397   }
21398   jresult = new Dali::Texture((const Dali::Texture &)result);
21399   return jresult;
21400 }
21401
21402
21403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21404   void * jresult ;
21405   Dali::Texture *result = 0 ;
21406
21407   {
21408     try {
21409       result = (Dali::Texture *)new Dali::Texture();
21410     } catch (std::out_of_range& e) {
21411       {
21412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21413       };
21414     } catch (std::exception& e) {
21415       {
21416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21417       };
21418     } catch (...) {
21419       {
21420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21421       };
21422     }
21423   }
21424   jresult = (void *)result;
21425   return jresult;
21426 }
21427
21428
21429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21430   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21431
21432   arg1 = (Dali::Texture *)jarg1;
21433   {
21434     try {
21435       delete arg1;
21436     } catch (std::out_of_range& e) {
21437       {
21438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21439       };
21440     } catch (std::exception& e) {
21441       {
21442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21443       };
21444     } catch (...) {
21445       {
21446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21447       };
21448     }
21449   }
21450 }
21451
21452
21453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21454   void * jresult ;
21455   Dali::Texture *arg1 = 0 ;
21456   Dali::Texture *result = 0 ;
21457
21458   arg1 = (Dali::Texture *)jarg1;
21459   if (!arg1) {
21460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21461     return 0;
21462   }
21463   {
21464     try {
21465       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21466     } catch (std::out_of_range& e) {
21467       {
21468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21469       };
21470     } catch (std::exception& e) {
21471       {
21472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21473       };
21474     } catch (...) {
21475       {
21476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21477       };
21478     }
21479   }
21480   jresult = (void *)result;
21481   return jresult;
21482 }
21483
21484
21485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21486   void * jresult ;
21487   Dali::BaseHandle arg1 ;
21488   Dali::BaseHandle *argp1 ;
21489   Dali::Texture result;
21490
21491   argp1 = (Dali::BaseHandle *)jarg1;
21492   if (!argp1) {
21493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21494     return 0;
21495   }
21496   arg1 = *argp1;
21497   {
21498     try {
21499       result = Dali::Texture::DownCast(arg1);
21500     } catch (std::out_of_range& e) {
21501       {
21502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21503       };
21504     } catch (std::exception& e) {
21505       {
21506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21507       };
21508     } catch (...) {
21509       {
21510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21511       };
21512     }
21513   }
21514   jresult = new Dali::Texture((const Dali::Texture &)result);
21515   return jresult;
21516 }
21517
21518
21519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21520   void * jresult ;
21521   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21522   Dali::Texture *arg2 = 0 ;
21523   Dali::Texture *result = 0 ;
21524
21525   arg1 = (Dali::Texture *)jarg1;
21526   arg2 = (Dali::Texture *)jarg2;
21527   if (!arg2) {
21528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21529     return 0;
21530   }
21531   {
21532     try {
21533       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21534     } catch (std::out_of_range& e) {
21535       {
21536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21537       };
21538     } catch (std::exception& e) {
21539       {
21540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21541       };
21542     } catch (...) {
21543       {
21544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21545       };
21546     }
21547   }
21548   jresult = (void *)result;
21549   return jresult;
21550 }
21551
21552
21553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21554   unsigned int jresult ;
21555   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21556   Dali::PixelData arg2 ;
21557   Dali::PixelData *argp2 ;
21558   bool result;
21559
21560   arg1 = (Dali::Texture *)jarg1;
21561   argp2 = (Dali::PixelData *)jarg2;
21562   if (!argp2) {
21563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21564     return 0;
21565   }
21566   arg2 = *argp2;
21567   {
21568     try {
21569       result = (bool)(arg1)->Upload(arg2);
21570     } catch (std::out_of_range& e) {
21571       {
21572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21573       };
21574     } catch (std::exception& e) {
21575       {
21576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21577       };
21578     } catch (...) {
21579       {
21580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21581       };
21582     }
21583   }
21584   jresult = result;
21585   return jresult;
21586 }
21587
21588
21589 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) {
21590   unsigned int jresult ;
21591   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21592   Dali::PixelData arg2 ;
21593   unsigned int arg3 ;
21594   unsigned int arg4 ;
21595   unsigned int arg5 ;
21596   unsigned int arg6 ;
21597   unsigned int arg7 ;
21598   unsigned int arg8 ;
21599   Dali::PixelData *argp2 ;
21600   bool result;
21601
21602   arg1 = (Dali::Texture *)jarg1;
21603   argp2 = (Dali::PixelData *)jarg2;
21604   if (!argp2) {
21605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21606     return 0;
21607   }
21608   arg2 = *argp2;
21609   arg3 = (unsigned int)jarg3;
21610   arg4 = (unsigned int)jarg4;
21611   arg5 = (unsigned int)jarg5;
21612   arg6 = (unsigned int)jarg6;
21613   arg7 = (unsigned int)jarg7;
21614   arg8 = (unsigned int)jarg8;
21615   {
21616     try {
21617       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21618     } catch (std::out_of_range& e) {
21619       {
21620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21621       };
21622     } catch (std::exception& e) {
21623       {
21624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21625       };
21626     } catch (...) {
21627       {
21628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21629       };
21630     }
21631   }
21632   jresult = result;
21633   return jresult;
21634 }
21635
21636
21637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21638   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21639
21640   arg1 = (Dali::Texture *)jarg1;
21641   {
21642     try {
21643       (arg1)->GenerateMipmaps();
21644     } catch (std::out_of_range& e) {
21645       {
21646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21647       };
21648     } catch (std::exception& e) {
21649       {
21650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21651       };
21652     } catch (...) {
21653       {
21654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21655       };
21656     }
21657   }
21658 }
21659
21660
21661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21662   unsigned int jresult ;
21663   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21664   unsigned int result;
21665
21666   arg1 = (Dali::Texture *)jarg1;
21667   {
21668     try {
21669       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21670     } catch (std::out_of_range& e) {
21671       {
21672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21673       };
21674     } catch (std::exception& e) {
21675       {
21676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21677       };
21678     } catch (...) {
21679       {
21680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21681       };
21682     }
21683   }
21684   jresult = result;
21685   return jresult;
21686 }
21687
21688
21689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21690   unsigned int jresult ;
21691   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21692   unsigned int result;
21693
21694   arg1 = (Dali::Texture *)jarg1;
21695   {
21696     try {
21697       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21698     } catch (std::out_of_range& e) {
21699       {
21700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21701       };
21702     } catch (std::exception& e) {
21703       {
21704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21705       };
21706     } catch (...) {
21707       {
21708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21709       };
21710     }
21711   }
21712   jresult = result;
21713   return jresult;
21714 }
21715
21716
21717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21718   void * jresult ;
21719   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21720   Dali::Texture *result = 0 ;
21721
21722   arg1 = (Dali::Internal::Texture *)jarg1;
21723   {
21724     try {
21725       result = (Dali::Texture *)new Dali::Texture(arg1);
21726     } catch (std::out_of_range& e) {
21727       {
21728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21729       };
21730     } catch (std::exception& e) {
21731       {
21732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21733       };
21734     } catch (...) {
21735       {
21736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21737       };
21738     }
21739   }
21740   jresult = (void *)result;
21741   return jresult;
21742 }
21743
21744
21745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21746   void * jresult ;
21747   Dali::Sampler result;
21748
21749   {
21750     try {
21751       result = Dali::Sampler::New();
21752     } catch (std::out_of_range& e) {
21753       {
21754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21755       };
21756     } catch (std::exception& e) {
21757       {
21758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21759       };
21760     } catch (...) {
21761       {
21762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21763       };
21764     }
21765   }
21766   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21767   return jresult;
21768 }
21769
21770
21771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21772   void * jresult ;
21773   Dali::Sampler *result = 0 ;
21774
21775   {
21776     try {
21777       result = (Dali::Sampler *)new Dali::Sampler();
21778     } catch (std::out_of_range& e) {
21779       {
21780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21781       };
21782     } catch (std::exception& e) {
21783       {
21784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21785       };
21786     } catch (...) {
21787       {
21788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21789       };
21790     }
21791   }
21792   jresult = (void *)result;
21793   return jresult;
21794 }
21795
21796
21797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21798   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21799
21800   arg1 = (Dali::Sampler *)jarg1;
21801   {
21802     try {
21803       delete arg1;
21804     } catch (std::out_of_range& e) {
21805       {
21806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21807       };
21808     } catch (std::exception& e) {
21809       {
21810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21811       };
21812     } catch (...) {
21813       {
21814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21815       };
21816     }
21817   }
21818 }
21819
21820
21821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21822   void * jresult ;
21823   Dali::Sampler *arg1 = 0 ;
21824   Dali::Sampler *result = 0 ;
21825
21826   arg1 = (Dali::Sampler *)jarg1;
21827   if (!arg1) {
21828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21829     return 0;
21830   }
21831   {
21832     try {
21833       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21834     } catch (std::out_of_range& e) {
21835       {
21836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21837       };
21838     } catch (std::exception& e) {
21839       {
21840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21841       };
21842     } catch (...) {
21843       {
21844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21845       };
21846     }
21847   }
21848   jresult = (void *)result;
21849   return jresult;
21850 }
21851
21852
21853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21854   void * jresult ;
21855   Dali::BaseHandle arg1 ;
21856   Dali::BaseHandle *argp1 ;
21857   Dali::Sampler result;
21858
21859   argp1 = (Dali::BaseHandle *)jarg1;
21860   if (!argp1) {
21861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21862     return 0;
21863   }
21864   arg1 = *argp1;
21865   {
21866     try {
21867       result = Dali::Sampler::DownCast(arg1);
21868     } catch (std::out_of_range& e) {
21869       {
21870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21871       };
21872     } catch (std::exception& e) {
21873       {
21874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21875       };
21876     } catch (...) {
21877       {
21878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21879       };
21880     }
21881   }
21882   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21883   return jresult;
21884 }
21885
21886
21887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21888   void * jresult ;
21889   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21890   Dali::Sampler *arg2 = 0 ;
21891   Dali::Sampler *result = 0 ;
21892
21893   arg1 = (Dali::Sampler *)jarg1;
21894   arg2 = (Dali::Sampler *)jarg2;
21895   if (!arg2) {
21896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21897     return 0;
21898   }
21899   {
21900     try {
21901       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21902     } catch (std::out_of_range& e) {
21903       {
21904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21905       };
21906     } catch (std::exception& e) {
21907       {
21908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21909       };
21910     } catch (...) {
21911       {
21912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21913       };
21914     }
21915   }
21916   jresult = (void *)result;
21917   return jresult;
21918 }
21919
21920
21921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21922   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21923   Dali::FilterMode::Type arg2 ;
21924   Dali::FilterMode::Type arg3 ;
21925
21926   arg1 = (Dali::Sampler *)jarg1;
21927   arg2 = (Dali::FilterMode::Type)jarg2;
21928   arg3 = (Dali::FilterMode::Type)jarg3;
21929   {
21930     try {
21931       (arg1)->SetFilterMode(arg2,arg3);
21932     } catch (std::out_of_range& e) {
21933       {
21934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21935       };
21936     } catch (std::exception& e) {
21937       {
21938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21939       };
21940     } catch (...) {
21941       {
21942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21943       };
21944     }
21945   }
21946 }
21947
21948
21949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21950   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21951   Dali::WrapMode::Type arg2 ;
21952   Dali::WrapMode::Type arg3 ;
21953
21954   arg1 = (Dali::Sampler *)jarg1;
21955   arg2 = (Dali::WrapMode::Type)jarg2;
21956   arg3 = (Dali::WrapMode::Type)jarg3;
21957   {
21958     try {
21959       (arg1)->SetWrapMode(arg2,arg3);
21960     } catch (std::out_of_range& e) {
21961       {
21962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21963       };
21964     } catch (std::exception& e) {
21965       {
21966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21967       };
21968     } catch (...) {
21969       {
21970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21971       };
21972     }
21973   }
21974 }
21975
21976
21977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21978   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21979   Dali::WrapMode::Type arg2 ;
21980   Dali::WrapMode::Type arg3 ;
21981   Dali::WrapMode::Type arg4 ;
21982
21983   arg1 = (Dali::Sampler *)jarg1;
21984   arg2 = (Dali::WrapMode::Type)jarg2;
21985   arg3 = (Dali::WrapMode::Type)jarg3;
21986   arg4 = (Dali::WrapMode::Type)jarg4;
21987   {
21988     try {
21989       (arg1)->SetWrapMode(arg2,arg3,arg4);
21990     } catch (std::out_of_range& e) {
21991       {
21992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21993       };
21994     } catch (std::exception& e) {
21995       {
21996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21997       };
21998     } catch (...) {
21999       {
22000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22001       };
22002     }
22003   }
22004 }
22005
22006
22007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22008   void * jresult ;
22009   Dali::TextureSet result;
22010
22011   {
22012     try {
22013       result = Dali::TextureSet::New();
22014     } catch (std::out_of_range& e) {
22015       {
22016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22017       };
22018     } catch (std::exception& e) {
22019       {
22020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22021       };
22022     } catch (...) {
22023       {
22024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22025       };
22026     }
22027   }
22028   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22029   return jresult;
22030 }
22031
22032
22033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22034   void * jresult ;
22035   Dali::TextureSet *result = 0 ;
22036
22037   {
22038     try {
22039       result = (Dali::TextureSet *)new Dali::TextureSet();
22040     } catch (std::out_of_range& e) {
22041       {
22042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22043       };
22044     } catch (std::exception& e) {
22045       {
22046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22047       };
22048     } catch (...) {
22049       {
22050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22051       };
22052     }
22053   }
22054   jresult = (void *)result;
22055   return jresult;
22056 }
22057
22058
22059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22060   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22061
22062   arg1 = (Dali::TextureSet *)jarg1;
22063   {
22064     try {
22065       delete arg1;
22066     } catch (std::out_of_range& e) {
22067       {
22068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22069       };
22070     } catch (std::exception& e) {
22071       {
22072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22073       };
22074     } catch (...) {
22075       {
22076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22077       };
22078     }
22079   }
22080 }
22081
22082
22083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22084   void * jresult ;
22085   Dali::TextureSet *arg1 = 0 ;
22086   Dali::TextureSet *result = 0 ;
22087
22088   arg1 = (Dali::TextureSet *)jarg1;
22089   if (!arg1) {
22090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22091     return 0;
22092   }
22093   {
22094     try {
22095       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22096     } catch (std::out_of_range& e) {
22097       {
22098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22099       };
22100     } catch (std::exception& e) {
22101       {
22102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22103       };
22104     } catch (...) {
22105       {
22106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22107       };
22108     }
22109   }
22110   jresult = (void *)result;
22111   return jresult;
22112 }
22113
22114
22115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22116   void * jresult ;
22117   Dali::BaseHandle arg1 ;
22118   Dali::BaseHandle *argp1 ;
22119   Dali::TextureSet result;
22120
22121   argp1 = (Dali::BaseHandle *)jarg1;
22122   if (!argp1) {
22123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22124     return 0;
22125   }
22126   arg1 = *argp1;
22127   {
22128     try {
22129       result = Dali::TextureSet::DownCast(arg1);
22130     } catch (std::out_of_range& e) {
22131       {
22132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22133       };
22134     } catch (std::exception& e) {
22135       {
22136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22137       };
22138     } catch (...) {
22139       {
22140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22141       };
22142     }
22143   }
22144   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22145   return jresult;
22146 }
22147
22148
22149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22150   void * jresult ;
22151   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22152   Dali::TextureSet *arg2 = 0 ;
22153   Dali::TextureSet *result = 0 ;
22154
22155   arg1 = (Dali::TextureSet *)jarg1;
22156   arg2 = (Dali::TextureSet *)jarg2;
22157   if (!arg2) {
22158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22159     return 0;
22160   }
22161   {
22162     try {
22163       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22164     } catch (std::out_of_range& e) {
22165       {
22166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22167       };
22168     } catch (std::exception& e) {
22169       {
22170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22171       };
22172     } catch (...) {
22173       {
22174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22175       };
22176     }
22177   }
22178   jresult = (void *)result;
22179   return jresult;
22180 }
22181
22182
22183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22184   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22185   size_t arg2 ;
22186   Dali::Texture arg3 ;
22187   Dali::Texture *argp3 ;
22188
22189   arg1 = (Dali::TextureSet *)jarg1;
22190   arg2 = (size_t)jarg2;
22191   argp3 = (Dali::Texture *)jarg3;
22192   if (!argp3) {
22193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22194     return ;
22195   }
22196   arg3 = *argp3;
22197   {
22198     try {
22199       (arg1)->SetTexture(arg2,arg3);
22200     } catch (std::out_of_range& e) {
22201       {
22202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22203       };
22204     } catch (std::exception& e) {
22205       {
22206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22207       };
22208     } catch (...) {
22209       {
22210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22211       };
22212     }
22213   }
22214 }
22215
22216
22217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22218   void * jresult ;
22219   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22220   size_t arg2 ;
22221   Dali::Texture result;
22222
22223   arg1 = (Dali::TextureSet *)jarg1;
22224   arg2 = (size_t)jarg2;
22225   {
22226     try {
22227       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22228     } catch (std::out_of_range& e) {
22229       {
22230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22231       };
22232     } catch (std::exception& e) {
22233       {
22234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22235       };
22236     } catch (...) {
22237       {
22238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22239       };
22240     }
22241   }
22242   jresult = new Dali::Texture((const Dali::Texture &)result);
22243   return jresult;
22244 }
22245
22246
22247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22248   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22249   size_t arg2 ;
22250   Dali::Sampler arg3 ;
22251   Dali::Sampler *argp3 ;
22252
22253   arg1 = (Dali::TextureSet *)jarg1;
22254   arg2 = (size_t)jarg2;
22255   argp3 = (Dali::Sampler *)jarg3;
22256   if (!argp3) {
22257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22258     return ;
22259   }
22260   arg3 = *argp3;
22261   {
22262     try {
22263       (arg1)->SetSampler(arg2,arg3);
22264     } catch (std::out_of_range& e) {
22265       {
22266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22267       };
22268     } catch (std::exception& e) {
22269       {
22270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22271       };
22272     } catch (...) {
22273       {
22274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22275       };
22276     }
22277   }
22278 }
22279
22280
22281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22282   void * jresult ;
22283   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22284   size_t arg2 ;
22285   Dali::Sampler result;
22286
22287   arg1 = (Dali::TextureSet *)jarg1;
22288   arg2 = (size_t)jarg2;
22289   {
22290     try {
22291       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22292     } catch (std::out_of_range& e) {
22293       {
22294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22295       };
22296     } catch (std::exception& e) {
22297       {
22298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22299       };
22300     } catch (...) {
22301       {
22302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22303       };
22304     }
22305   }
22306   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22307   return jresult;
22308 }
22309
22310
22311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22312   unsigned long jresult ;
22313   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22314   size_t result;
22315
22316   arg1 = (Dali::TextureSet *)jarg1;
22317   {
22318     try {
22319       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22320     } catch (std::out_of_range& e) {
22321       {
22322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22323       };
22324     } catch (std::exception& e) {
22325       {
22326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22327       };
22328     } catch (...) {
22329       {
22330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22331       };
22332     }
22333   }
22334   jresult = (unsigned long)result;
22335   return jresult;
22336 }
22337
22338
22339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22340   void * jresult ;
22341   Dali::Property::Map *arg1 = 0 ;
22342   Dali::PropertyBuffer result;
22343
22344   arg1 = (Dali::Property::Map *)jarg1;
22345   if (!arg1) {
22346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22347     return 0;
22348   }
22349   {
22350     try {
22351       result = Dali::PropertyBuffer::New(*arg1);
22352     } catch (std::out_of_range& e) {
22353       {
22354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22355       };
22356     } catch (std::exception& e) {
22357       {
22358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22359       };
22360     } catch (...) {
22361       {
22362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22363       };
22364     }
22365   }
22366   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22367   return jresult;
22368 }
22369
22370
22371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22372   void * jresult ;
22373   Dali::PropertyBuffer *result = 0 ;
22374
22375   {
22376     try {
22377       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22378     } catch (std::out_of_range& e) {
22379       {
22380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22381       };
22382     } catch (std::exception& e) {
22383       {
22384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22385       };
22386     } catch (...) {
22387       {
22388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22389       };
22390     }
22391   }
22392   jresult = (void *)result;
22393   return jresult;
22394 }
22395
22396
22397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22398   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22399
22400   arg1 = (Dali::PropertyBuffer *)jarg1;
22401   {
22402     try {
22403       delete arg1;
22404     } catch (std::out_of_range& e) {
22405       {
22406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22407       };
22408     } catch (std::exception& e) {
22409       {
22410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22411       };
22412     } catch (...) {
22413       {
22414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22415       };
22416     }
22417   }
22418 }
22419
22420
22421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22422   void * jresult ;
22423   Dali::PropertyBuffer *arg1 = 0 ;
22424   Dali::PropertyBuffer *result = 0 ;
22425
22426   arg1 = (Dali::PropertyBuffer *)jarg1;
22427   if (!arg1) {
22428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22429     return 0;
22430   }
22431   {
22432     try {
22433       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22434     } catch (std::out_of_range& e) {
22435       {
22436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22437       };
22438     } catch (std::exception& e) {
22439       {
22440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22441       };
22442     } catch (...) {
22443       {
22444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22445       };
22446     }
22447   }
22448   jresult = (void *)result;
22449   return jresult;
22450 }
22451
22452
22453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22454   void * jresult ;
22455   Dali::BaseHandle arg1 ;
22456   Dali::BaseHandle *argp1 ;
22457   Dali::PropertyBuffer result;
22458
22459   argp1 = (Dali::BaseHandle *)jarg1;
22460   if (!argp1) {
22461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22462     return 0;
22463   }
22464   arg1 = *argp1;
22465   {
22466     try {
22467       result = Dali::PropertyBuffer::DownCast(arg1);
22468     } catch (std::out_of_range& e) {
22469       {
22470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22471       };
22472     } catch (std::exception& e) {
22473       {
22474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22475       };
22476     } catch (...) {
22477       {
22478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22479       };
22480     }
22481   }
22482   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22483   return jresult;
22484 }
22485
22486
22487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22488   void * jresult ;
22489   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22490   Dali::PropertyBuffer *arg2 = 0 ;
22491   Dali::PropertyBuffer *result = 0 ;
22492
22493   arg1 = (Dali::PropertyBuffer *)jarg1;
22494   arg2 = (Dali::PropertyBuffer *)jarg2;
22495   if (!arg2) {
22496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22497     return 0;
22498   }
22499   {
22500     try {
22501       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22502     } catch (std::out_of_range& e) {
22503       {
22504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22505       };
22506     } catch (std::exception& e) {
22507       {
22508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22509       };
22510     } catch (...) {
22511       {
22512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22513       };
22514     }
22515   }
22516   jresult = (void *)result;
22517   return jresult;
22518 }
22519
22520
22521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22522   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22523   void *arg2 = (void *) 0 ;
22524   std::size_t arg3 ;
22525
22526   arg1 = (Dali::PropertyBuffer *)jarg1;
22527   arg2 = jarg2;
22528   arg3 = (std::size_t)jarg3;
22529   {
22530     try {
22531       (arg1)->SetData((void const *)arg2,arg3);
22532     } catch (std::out_of_range& e) {
22533       {
22534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22535       };
22536     } catch (std::exception& e) {
22537       {
22538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22539       };
22540     } catch (...) {
22541       {
22542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22543       };
22544     }
22545   }
22546 }
22547
22548
22549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22550   unsigned long jresult ;
22551   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22552   std::size_t result;
22553
22554   arg1 = (Dali::PropertyBuffer *)jarg1;
22555   {
22556     try {
22557       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22558     } catch (std::out_of_range& e) {
22559       {
22560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22561       };
22562     } catch (std::exception& e) {
22563       {
22564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22565       };
22566     } catch (...) {
22567       {
22568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22569       };
22570     }
22571   }
22572   jresult = (unsigned long)result;
22573   return jresult;
22574 }
22575
22576
22577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22578   void * jresult ;
22579   Dali::Geometry result;
22580
22581   {
22582     try {
22583       result = Dali::Geometry::New();
22584     } catch (std::out_of_range& e) {
22585       {
22586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22587       };
22588     } catch (std::exception& e) {
22589       {
22590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22591       };
22592     } catch (...) {
22593       {
22594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22595       };
22596     }
22597   }
22598   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22599   return jresult;
22600 }
22601
22602
22603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22604   void * jresult ;
22605   Dali::Geometry *result = 0 ;
22606
22607   {
22608     try {
22609       result = (Dali::Geometry *)new Dali::Geometry();
22610     } catch (std::out_of_range& e) {
22611       {
22612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22613       };
22614     } catch (std::exception& e) {
22615       {
22616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22617       };
22618     } catch (...) {
22619       {
22620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22621       };
22622     }
22623   }
22624   jresult = (void *)result;
22625   return jresult;
22626 }
22627
22628
22629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22630   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22631
22632   arg1 = (Dali::Geometry *)jarg1;
22633   {
22634     try {
22635       delete arg1;
22636     } catch (std::out_of_range& e) {
22637       {
22638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22639       };
22640     } catch (std::exception& e) {
22641       {
22642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22643       };
22644     } catch (...) {
22645       {
22646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22647       };
22648     }
22649   }
22650 }
22651
22652
22653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22654   void * jresult ;
22655   Dali::Geometry *arg1 = 0 ;
22656   Dali::Geometry *result = 0 ;
22657
22658   arg1 = (Dali::Geometry *)jarg1;
22659   if (!arg1) {
22660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22661     return 0;
22662   }
22663   {
22664     try {
22665       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22666     } catch (std::out_of_range& e) {
22667       {
22668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22669       };
22670     } catch (std::exception& e) {
22671       {
22672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22673       };
22674     } catch (...) {
22675       {
22676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22677       };
22678     }
22679   }
22680   jresult = (void *)result;
22681   return jresult;
22682 }
22683
22684
22685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22686   void * jresult ;
22687   Dali::BaseHandle arg1 ;
22688   Dali::BaseHandle *argp1 ;
22689   Dali::Geometry result;
22690
22691   argp1 = (Dali::BaseHandle *)jarg1;
22692   if (!argp1) {
22693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22694     return 0;
22695   }
22696   arg1 = *argp1;
22697   {
22698     try {
22699       result = Dali::Geometry::DownCast(arg1);
22700     } catch (std::out_of_range& e) {
22701       {
22702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22703       };
22704     } catch (std::exception& e) {
22705       {
22706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22707       };
22708     } catch (...) {
22709       {
22710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22711       };
22712     }
22713   }
22714   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22715   return jresult;
22716 }
22717
22718
22719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22720   void * jresult ;
22721   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22722   Dali::Geometry *arg2 = 0 ;
22723   Dali::Geometry *result = 0 ;
22724
22725   arg1 = (Dali::Geometry *)jarg1;
22726   arg2 = (Dali::Geometry *)jarg2;
22727   if (!arg2) {
22728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22729     return 0;
22730   }
22731   {
22732     try {
22733       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22734     } catch (std::out_of_range& e) {
22735       {
22736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22737       };
22738     } catch (std::exception& e) {
22739       {
22740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22741       };
22742     } catch (...) {
22743       {
22744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22745       };
22746     }
22747   }
22748   jresult = (void *)result;
22749   return jresult;
22750 }
22751
22752
22753 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22754   unsigned long jresult ;
22755   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22756   Dali::PropertyBuffer *arg2 = 0 ;
22757   std::size_t result;
22758
22759   arg1 = (Dali::Geometry *)jarg1;
22760   arg2 = (Dali::PropertyBuffer *)jarg2;
22761   if (!arg2) {
22762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22763     return 0;
22764   }
22765   {
22766     try {
22767       result = (arg1)->AddVertexBuffer(*arg2);
22768     } catch (std::out_of_range& e) {
22769       {
22770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22771       };
22772     } catch (std::exception& e) {
22773       {
22774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22775       };
22776     } catch (...) {
22777       {
22778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22779       };
22780     }
22781   }
22782   jresult = (unsigned long)result;
22783   return jresult;
22784 }
22785
22786
22787 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22788   unsigned long jresult ;
22789   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22790   std::size_t result;
22791
22792   arg1 = (Dali::Geometry *)jarg1;
22793   {
22794     try {
22795       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22796     } catch (std::out_of_range& e) {
22797       {
22798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22799       };
22800     } catch (std::exception& e) {
22801       {
22802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22803       };
22804     } catch (...) {
22805       {
22806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22807       };
22808     }
22809   }
22810   jresult = (unsigned long)result;
22811   return jresult;
22812 }
22813
22814
22815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22816   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22817   std::size_t arg2 ;
22818
22819   arg1 = (Dali::Geometry *)jarg1;
22820   arg2 = (std::size_t)jarg2;
22821   {
22822     try {
22823       (arg1)->RemoveVertexBuffer(arg2);
22824     } catch (std::out_of_range& e) {
22825       {
22826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22827       };
22828     } catch (std::exception& e) {
22829       {
22830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22831       };
22832     } catch (...) {
22833       {
22834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22835       };
22836     }
22837   }
22838 }
22839
22840
22841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22842   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22843   unsigned short *arg2 = (unsigned short *) 0 ;
22844   size_t arg3 ;
22845
22846   arg1 = (Dali::Geometry *)jarg1;
22847   arg2 = jarg2;
22848   arg3 = (size_t)jarg3;
22849   {
22850     try {
22851       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22852     } catch (std::out_of_range& e) {
22853       {
22854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22855       };
22856     } catch (std::exception& e) {
22857       {
22858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22859       };
22860     } catch (...) {
22861       {
22862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22863       };
22864     }
22865   }
22866
22867
22868 }
22869
22870
22871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22872   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22873   Dali::Geometry::Type arg2 ;
22874
22875   arg1 = (Dali::Geometry *)jarg1;
22876   arg2 = (Dali::Geometry::Type)jarg2;
22877   {
22878     try {
22879       (arg1)->SetType(arg2);
22880     } catch (std::out_of_range& e) {
22881       {
22882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22883       };
22884     } catch (std::exception& e) {
22885       {
22886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22887       };
22888     } catch (...) {
22889       {
22890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22891       };
22892     }
22893   }
22894 }
22895
22896
22897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22898   int jresult ;
22899   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22900   Dali::Geometry::Type result;
22901
22902   arg1 = (Dali::Geometry *)jarg1;
22903   {
22904     try {
22905       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22906     } catch (std::out_of_range& e) {
22907       {
22908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22909       };
22910     } catch (std::exception& e) {
22911       {
22912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22913       };
22914     } catch (...) {
22915       {
22916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22917       };
22918     }
22919   }
22920   jresult = (int)result;
22921   return jresult;
22922 }
22923
22924
22925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22926   void * jresult ;
22927   Dali::Shader::Hint *result = 0 ;
22928
22929   {
22930     try {
22931       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22932     } catch (std::out_of_range& e) {
22933       {
22934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22935       };
22936     } catch (std::exception& e) {
22937       {
22938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22939       };
22940     } catch (...) {
22941       {
22942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22943       };
22944     }
22945   }
22946   jresult = (void *)result;
22947   return jresult;
22948 }
22949
22950
22951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22952   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22953
22954   arg1 = (Dali::Shader::Hint *)jarg1;
22955   {
22956     try {
22957       delete arg1;
22958     } catch (std::out_of_range& e) {
22959       {
22960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22961       };
22962     } catch (std::exception& e) {
22963       {
22964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22965       };
22966     } catch (...) {
22967       {
22968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22969       };
22970     }
22971   }
22972 }
22973
22974
22975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22976   int jresult ;
22977   int result;
22978
22979   result = (int)Dali::Shader::Property::PROGRAM;
22980   jresult = (int)result;
22981   return jresult;
22982 }
22983
22984
22985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
22986   void * jresult ;
22987   Dali::Shader::Property *result = 0 ;
22988
22989   {
22990     try {
22991       result = (Dali::Shader::Property *)new Dali::Shader::Property();
22992     } catch (std::out_of_range& e) {
22993       {
22994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22995       };
22996     } catch (std::exception& e) {
22997       {
22998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22999       };
23000     } catch (...) {
23001       {
23002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23003       };
23004     }
23005   }
23006   jresult = (void *)result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23012   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23013
23014   arg1 = (Dali::Shader::Property *)jarg1;
23015   {
23016     try {
23017       delete arg1;
23018     } catch (std::out_of_range& e) {
23019       {
23020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23021       };
23022     } catch (std::exception& e) {
23023       {
23024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23025       };
23026     } catch (...) {
23027       {
23028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23029       };
23030     }
23031   }
23032 }
23033
23034
23035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23036   void * jresult ;
23037   std::string *arg1 = 0 ;
23038   std::string *arg2 = 0 ;
23039   Dali::Shader::Hint::Value arg3 ;
23040   Dali::Shader result;
23041
23042   if (!jarg1) {
23043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23044     return 0;
23045   }
23046   std::string arg1_str(jarg1);
23047   arg1 = &arg1_str;
23048   if (!jarg2) {
23049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23050     return 0;
23051   }
23052   std::string arg2_str(jarg2);
23053   arg2 = &arg2_str;
23054   arg3 = (Dali::Shader::Hint::Value)jarg3;
23055   {
23056     try {
23057       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23058     } catch (std::out_of_range& e) {
23059       {
23060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23061       };
23062     } catch (std::exception& e) {
23063       {
23064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23065       };
23066     } catch (...) {
23067       {
23068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23069       };
23070     }
23071   }
23072   jresult = new Dali::Shader((const Dali::Shader &)result);
23073
23074   //argout typemap for const std::string&
23075
23076
23077   //argout typemap for const std::string&
23078
23079   return jresult;
23080 }
23081
23082
23083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23084   void * jresult ;
23085   std::string *arg1 = 0 ;
23086   std::string *arg2 = 0 ;
23087   Dali::Shader result;
23088
23089   if (!jarg1) {
23090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23091     return 0;
23092   }
23093   std::string arg1_str(jarg1);
23094   arg1 = &arg1_str;
23095   if (!jarg2) {
23096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23097     return 0;
23098   }
23099   std::string arg2_str(jarg2);
23100   arg2 = &arg2_str;
23101   {
23102     try {
23103       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23104     } catch (std::out_of_range& e) {
23105       {
23106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23107       };
23108     } catch (std::exception& e) {
23109       {
23110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23111       };
23112     } catch (...) {
23113       {
23114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23115       };
23116     }
23117   }
23118   jresult = new Dali::Shader((const Dali::Shader &)result);
23119
23120   //argout typemap for const std::string&
23121
23122
23123   //argout typemap for const std::string&
23124
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23130   void * jresult ;
23131   Dali::Shader *result = 0 ;
23132
23133   {
23134     try {
23135       result = (Dali::Shader *)new Dali::Shader();
23136     } catch (std::out_of_range& e) {
23137       {
23138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23139       };
23140     } catch (std::exception& e) {
23141       {
23142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23143       };
23144     } catch (...) {
23145       {
23146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23147       };
23148     }
23149   }
23150   jresult = (void *)result;
23151   return jresult;
23152 }
23153
23154
23155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23156   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23157
23158   arg1 = (Dali::Shader *)jarg1;
23159   {
23160     try {
23161       delete arg1;
23162     } catch (std::out_of_range& e) {
23163       {
23164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23165       };
23166     } catch (std::exception& e) {
23167       {
23168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23169       };
23170     } catch (...) {
23171       {
23172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23173       };
23174     }
23175   }
23176 }
23177
23178
23179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23180   void * jresult ;
23181   Dali::Shader *arg1 = 0 ;
23182   Dali::Shader *result = 0 ;
23183
23184   arg1 = (Dali::Shader *)jarg1;
23185   if (!arg1) {
23186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23187     return 0;
23188   }
23189   {
23190     try {
23191       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23192     } catch (std::out_of_range& e) {
23193       {
23194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23195       };
23196     } catch (std::exception& e) {
23197       {
23198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23199       };
23200     } catch (...) {
23201       {
23202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23203       };
23204     }
23205   }
23206   jresult = (void *)result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23212   void * jresult ;
23213   Dali::BaseHandle arg1 ;
23214   Dali::BaseHandle *argp1 ;
23215   Dali::Shader result;
23216
23217   argp1 = (Dali::BaseHandle *)jarg1;
23218   if (!argp1) {
23219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23220     return 0;
23221   }
23222   arg1 = *argp1;
23223   {
23224     try {
23225       result = Dali::Shader::DownCast(arg1);
23226     } catch (std::out_of_range& e) {
23227       {
23228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23229       };
23230     } catch (std::exception& e) {
23231       {
23232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23233       };
23234     } catch (...) {
23235       {
23236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23237       };
23238     }
23239   }
23240   jresult = new Dali::Shader((const Dali::Shader &)result);
23241   return jresult;
23242 }
23243
23244
23245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23246   void * jresult ;
23247   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23248   Dali::Shader *arg2 = 0 ;
23249   Dali::Shader *result = 0 ;
23250
23251   arg1 = (Dali::Shader *)jarg1;
23252   arg2 = (Dali::Shader *)jarg2;
23253   if (!arg2) {
23254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23255     return 0;
23256   }
23257   {
23258     try {
23259       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23260     } catch (std::out_of_range& e) {
23261       {
23262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23263       };
23264     } catch (std::exception& e) {
23265       {
23266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23267       };
23268     } catch (...) {
23269       {
23270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23271       };
23272     }
23273   }
23274   jresult = (void *)result;
23275   return jresult;
23276 }
23277
23278
23279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23280   int jresult ;
23281   int result;
23282
23283   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23284   jresult = (int)result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23290   int jresult ;
23291   int result;
23292
23293   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23294   jresult = (int)result;
23295   return jresult;
23296 }
23297
23298
23299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23300   int jresult ;
23301   int result;
23302
23303   result = (int)Dali::Renderer::Property::BLEND_MODE;
23304   jresult = (int)result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23310   int jresult ;
23311   int result;
23312
23313   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23314   jresult = (int)result;
23315   return jresult;
23316 }
23317
23318
23319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23320   int jresult ;
23321   int result;
23322
23323   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23324   jresult = (int)result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23330   int jresult ;
23331   int result;
23332
23333   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23334   jresult = (int)result;
23335   return jresult;
23336 }
23337
23338
23339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23340   int jresult ;
23341   int result;
23342
23343   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23344   jresult = (int)result;
23345   return jresult;
23346 }
23347
23348
23349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23350   int jresult ;
23351   int result;
23352
23353   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23354   jresult = (int)result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23360   int jresult ;
23361   int result;
23362
23363   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23364   jresult = (int)result;
23365   return jresult;
23366 }
23367
23368
23369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23370   int jresult ;
23371   int result;
23372
23373   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23374   jresult = (int)result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23380   int jresult ;
23381   int result;
23382
23383   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23384   jresult = (int)result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23390   int jresult ;
23391   int result;
23392
23393   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23394   jresult = (int)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23400   int jresult ;
23401   int result;
23402
23403   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23404   jresult = (int)result;
23405   return jresult;
23406 }
23407
23408
23409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23410   int jresult ;
23411   int result;
23412
23413   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23414   jresult = (int)result;
23415   return jresult;
23416 }
23417
23418
23419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23420   int jresult ;
23421   int result;
23422
23423   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23424   jresult = (int)result;
23425   return jresult;
23426 }
23427
23428
23429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23430   int jresult ;
23431   int result;
23432
23433   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23434   jresult = (int)result;
23435   return jresult;
23436 }
23437
23438
23439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23440   int jresult ;
23441   int result;
23442
23443   result = (int)Dali::Renderer::Property::RENDER_MODE;
23444   jresult = (int)result;
23445   return jresult;
23446 }
23447
23448
23449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23450   int jresult ;
23451   int result;
23452
23453   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23454   jresult = (int)result;
23455   return jresult;
23456 }
23457
23458
23459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23460   int jresult ;
23461   int result;
23462
23463   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23464   jresult = (int)result;
23465   return jresult;
23466 }
23467
23468
23469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23470   int jresult ;
23471   int result;
23472
23473   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23474   jresult = (int)result;
23475   return jresult;
23476 }
23477
23478
23479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23480   int jresult ;
23481   int result;
23482
23483   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23484   jresult = (int)result;
23485   return jresult;
23486 }
23487
23488
23489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23490   int jresult ;
23491   int result;
23492
23493   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23494   jresult = (int)result;
23495   return jresult;
23496 }
23497
23498
23499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23500   int jresult ;
23501   int result;
23502
23503   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23504   jresult = (int)result;
23505   return jresult;
23506 }
23507
23508
23509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23510   int jresult ;
23511   int result;
23512
23513   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23514   jresult = (int)result;
23515   return jresult;
23516 }
23517
23518
23519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23520   void * jresult ;
23521   Dali::Renderer::Property *result = 0 ;
23522
23523   {
23524     try {
23525       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23526     } catch (std::out_of_range& e) {
23527       {
23528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23529       };
23530     } catch (std::exception& e) {
23531       {
23532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23533       };
23534     } catch (...) {
23535       {
23536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23537       };
23538     }
23539   }
23540   jresult = (void *)result;
23541   return jresult;
23542 }
23543
23544
23545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23546   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23547
23548   arg1 = (Dali::Renderer::Property *)jarg1;
23549   {
23550     try {
23551       delete arg1;
23552     } catch (std::out_of_range& e) {
23553       {
23554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23555       };
23556     } catch (std::exception& e) {
23557       {
23558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23559       };
23560     } catch (...) {
23561       {
23562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23563       };
23564     }
23565   }
23566 }
23567
23568
23569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23570   void * jresult ;
23571   Dali::Geometry *arg1 = 0 ;
23572   Dali::Shader *arg2 = 0 ;
23573   Dali::Renderer result;
23574
23575   arg1 = (Dali::Geometry *)jarg1;
23576   if (!arg1) {
23577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23578     return 0;
23579   }
23580   arg2 = (Dali::Shader *)jarg2;
23581   if (!arg2) {
23582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23583     return 0;
23584   }
23585   {
23586     try {
23587       result = Dali::Renderer::New(*arg1,*arg2);
23588     } catch (std::out_of_range& e) {
23589       {
23590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23591       };
23592     } catch (std::exception& e) {
23593       {
23594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23595       };
23596     } catch (...) {
23597       {
23598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23599       };
23600     }
23601   }
23602   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23603   return jresult;
23604 }
23605
23606
23607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23608   void * jresult ;
23609   Dali::Renderer *result = 0 ;
23610
23611   {
23612     try {
23613       result = (Dali::Renderer *)new Dali::Renderer();
23614     } catch (std::out_of_range& e) {
23615       {
23616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23617       };
23618     } catch (std::exception& e) {
23619       {
23620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23621       };
23622     } catch (...) {
23623       {
23624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23625       };
23626     }
23627   }
23628   jresult = (void *)result;
23629   return jresult;
23630 }
23631
23632
23633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23634   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23635
23636   arg1 = (Dali::Renderer *)jarg1;
23637   {
23638     try {
23639       delete arg1;
23640     } catch (std::out_of_range& e) {
23641       {
23642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23643       };
23644     } catch (std::exception& e) {
23645       {
23646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23647       };
23648     } catch (...) {
23649       {
23650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23651       };
23652     }
23653   }
23654 }
23655
23656
23657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23658   void * jresult ;
23659   Dali::Renderer *arg1 = 0 ;
23660   Dali::Renderer *result = 0 ;
23661
23662   arg1 = (Dali::Renderer *)jarg1;
23663   if (!arg1) {
23664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23665     return 0;
23666   }
23667   {
23668     try {
23669       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23670     } catch (std::out_of_range& e) {
23671       {
23672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23673       };
23674     } catch (std::exception& e) {
23675       {
23676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23677       };
23678     } catch (...) {
23679       {
23680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23681       };
23682     }
23683   }
23684   jresult = (void *)result;
23685   return jresult;
23686 }
23687
23688
23689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23690   void * jresult ;
23691   Dali::BaseHandle arg1 ;
23692   Dali::BaseHandle *argp1 ;
23693   Dali::Renderer result;
23694
23695   argp1 = (Dali::BaseHandle *)jarg1;
23696   if (!argp1) {
23697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23698     return 0;
23699   }
23700   arg1 = *argp1;
23701   {
23702     try {
23703       result = Dali::Renderer::DownCast(arg1);
23704     } catch (std::out_of_range& e) {
23705       {
23706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23707       };
23708     } catch (std::exception& e) {
23709       {
23710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23711       };
23712     } catch (...) {
23713       {
23714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23715       };
23716     }
23717   }
23718   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23719   return jresult;
23720 }
23721
23722
23723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23724   void * jresult ;
23725   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23726   Dali::Renderer *arg2 = 0 ;
23727   Dali::Renderer *result = 0 ;
23728
23729   arg1 = (Dali::Renderer *)jarg1;
23730   arg2 = (Dali::Renderer *)jarg2;
23731   if (!arg2) {
23732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23733     return 0;
23734   }
23735   {
23736     try {
23737       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23738     } catch (std::out_of_range& e) {
23739       {
23740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23741       };
23742     } catch (std::exception& e) {
23743       {
23744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23745       };
23746     } catch (...) {
23747       {
23748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23749       };
23750     }
23751   }
23752   jresult = (void *)result;
23753   return jresult;
23754 }
23755
23756
23757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23758   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23759   Dali::Geometry *arg2 = 0 ;
23760
23761   arg1 = (Dali::Renderer *)jarg1;
23762   arg2 = (Dali::Geometry *)jarg2;
23763   if (!arg2) {
23764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23765     return ;
23766   }
23767   {
23768     try {
23769       (arg1)->SetGeometry(*arg2);
23770     } catch (std::out_of_range& e) {
23771       {
23772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23773       };
23774     } catch (std::exception& e) {
23775       {
23776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23777       };
23778     } catch (...) {
23779       {
23780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23781       };
23782     }
23783   }
23784 }
23785
23786
23787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23788   void * jresult ;
23789   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23790   Dali::Geometry result;
23791
23792   arg1 = (Dali::Renderer *)jarg1;
23793   {
23794     try {
23795       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23796     } catch (std::out_of_range& e) {
23797       {
23798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23799       };
23800     } catch (std::exception& e) {
23801       {
23802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23803       };
23804     } catch (...) {
23805       {
23806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23807       };
23808     }
23809   }
23810   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23811   return jresult;
23812 }
23813
23814
23815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23816   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23817   int arg2 ;
23818   int arg3 ;
23819
23820   arg1 = (Dali::Renderer *)jarg1;
23821   arg2 = (int)jarg2;
23822   arg3 = (int)jarg3;
23823   {
23824     try {
23825       (arg1)->SetIndexRange(arg2,arg3);
23826     } catch (std::out_of_range& e) {
23827       {
23828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23829       };
23830     } catch (std::exception& e) {
23831       {
23832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23833       };
23834     } catch (...) {
23835       {
23836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23837       };
23838     }
23839   }
23840 }
23841
23842
23843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23844   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23845   Dali::TextureSet *arg2 = 0 ;
23846
23847   arg1 = (Dali::Renderer *)jarg1;
23848   arg2 = (Dali::TextureSet *)jarg2;
23849   if (!arg2) {
23850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23851     return ;
23852   }
23853   {
23854     try {
23855       (arg1)->SetTextures(*arg2);
23856     } catch (std::out_of_range& e) {
23857       {
23858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23859       };
23860     } catch (std::exception& e) {
23861       {
23862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23863       };
23864     } catch (...) {
23865       {
23866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23867       };
23868     }
23869   }
23870 }
23871
23872
23873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23874   void * jresult ;
23875   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23876   Dali::TextureSet result;
23877
23878   arg1 = (Dali::Renderer *)jarg1;
23879   {
23880     try {
23881       result = ((Dali::Renderer const *)arg1)->GetTextures();
23882     } catch (std::out_of_range& e) {
23883       {
23884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23885       };
23886     } catch (std::exception& e) {
23887       {
23888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23889       };
23890     } catch (...) {
23891       {
23892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23893       };
23894     }
23895   }
23896   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23897   return jresult;
23898 }
23899
23900
23901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23902   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23903   Dali::Shader *arg2 = 0 ;
23904
23905   arg1 = (Dali::Renderer *)jarg1;
23906   arg2 = (Dali::Shader *)jarg2;
23907   if (!arg2) {
23908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23909     return ;
23910   }
23911   {
23912     try {
23913       (arg1)->SetShader(*arg2);
23914     } catch (std::out_of_range& e) {
23915       {
23916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23917       };
23918     } catch (std::exception& e) {
23919       {
23920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23921       };
23922     } catch (...) {
23923       {
23924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23925       };
23926     }
23927   }
23928 }
23929
23930
23931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23932   void * jresult ;
23933   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23934   Dali::Shader result;
23935
23936   arg1 = (Dali::Renderer *)jarg1;
23937   {
23938     try {
23939       result = ((Dali::Renderer const *)arg1)->GetShader();
23940     } catch (std::out_of_range& e) {
23941       {
23942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23943       };
23944     } catch (std::exception& e) {
23945       {
23946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23947       };
23948     } catch (...) {
23949       {
23950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23951       };
23952     }
23953   }
23954   jresult = new Dali::Shader((const Dali::Shader &)result);
23955   return jresult;
23956 }
23957
23958
23959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23960   void * jresult ;
23961   Dali::FrameBuffer::Attachment *result = 0 ;
23962
23963   {
23964     try {
23965       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23966     } catch (std::out_of_range& e) {
23967       {
23968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23969       };
23970     } catch (std::exception& e) {
23971       {
23972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23973       };
23974     } catch (...) {
23975       {
23976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23977       };
23978     }
23979   }
23980   jresult = (void *)result;
23981   return jresult;
23982 }
23983
23984
23985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
23986   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
23987
23988   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
23989   {
23990     try {
23991       delete arg1;
23992     } catch (std::out_of_range& e) {
23993       {
23994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23995       };
23996     } catch (std::exception& e) {
23997       {
23998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23999       };
24000     } catch (...) {
24001       {
24002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24003       };
24004     }
24005   }
24006 }
24007
24008
24009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24010   void * jresult ;
24011   unsigned int arg1 ;
24012   unsigned int arg2 ;
24013   unsigned int arg3 ;
24014   Dali::FrameBuffer result;
24015
24016   arg1 = (unsigned int)jarg1;
24017   arg2 = (unsigned int)jarg2;
24018   arg3 = (unsigned int)jarg3;
24019   {
24020     try {
24021       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24022     } catch (std::out_of_range& e) {
24023       {
24024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24025       };
24026     } catch (std::exception& e) {
24027       {
24028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24029       };
24030     } catch (...) {
24031       {
24032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24033       };
24034     }
24035   }
24036   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24037   return jresult;
24038 }
24039
24040
24041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24042   void * jresult ;
24043   Dali::FrameBuffer *result = 0 ;
24044
24045   {
24046     try {
24047       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24048     } catch (std::out_of_range& e) {
24049       {
24050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24051       };
24052     } catch (std::exception& e) {
24053       {
24054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24055       };
24056     } catch (...) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24059       };
24060     }
24061   }
24062   jresult = (void *)result;
24063   return jresult;
24064 }
24065
24066
24067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24068   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24069
24070   arg1 = (Dali::FrameBuffer *)jarg1;
24071   {
24072     try {
24073       delete arg1;
24074     } catch (std::out_of_range& e) {
24075       {
24076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24077       };
24078     } catch (std::exception& e) {
24079       {
24080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24081       };
24082     } catch (...) {
24083       {
24084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24085       };
24086     }
24087   }
24088 }
24089
24090
24091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24092   void * jresult ;
24093   Dali::FrameBuffer *arg1 = 0 ;
24094   Dali::FrameBuffer *result = 0 ;
24095
24096   arg1 = (Dali::FrameBuffer *)jarg1;
24097   if (!arg1) {
24098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24099     return 0;
24100   }
24101   {
24102     try {
24103       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24104     } catch (std::out_of_range& e) {
24105       {
24106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24107       };
24108     } catch (std::exception& e) {
24109       {
24110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24111       };
24112     } catch (...) {
24113       {
24114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24115       };
24116     }
24117   }
24118   jresult = (void *)result;
24119   return jresult;
24120 }
24121
24122
24123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24124   void * jresult ;
24125   Dali::BaseHandle arg1 ;
24126   Dali::BaseHandle *argp1 ;
24127   Dali::FrameBuffer result;
24128
24129   argp1 = (Dali::BaseHandle *)jarg1;
24130   if (!argp1) {
24131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24132     return 0;
24133   }
24134   arg1 = *argp1;
24135   {
24136     try {
24137       result = Dali::FrameBuffer::DownCast(arg1);
24138     } catch (std::out_of_range& e) {
24139       {
24140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24141       };
24142     } catch (std::exception& e) {
24143       {
24144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24145       };
24146     } catch (...) {
24147       {
24148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24149       };
24150     }
24151   }
24152   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24153   return jresult;
24154 }
24155
24156
24157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24158   void * jresult ;
24159   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24160   Dali::FrameBuffer *arg2 = 0 ;
24161   Dali::FrameBuffer *result = 0 ;
24162
24163   arg1 = (Dali::FrameBuffer *)jarg1;
24164   arg2 = (Dali::FrameBuffer *)jarg2;
24165   if (!arg2) {
24166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24167     return 0;
24168   }
24169   {
24170     try {
24171       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24172     } catch (std::out_of_range& e) {
24173       {
24174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24175       };
24176     } catch (std::exception& e) {
24177       {
24178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24179       };
24180     } catch (...) {
24181       {
24182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24183       };
24184     }
24185   }
24186   jresult = (void *)result;
24187   return jresult;
24188 }
24189
24190
24191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24192   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24193   Dali::Texture *arg2 = 0 ;
24194
24195   arg1 = (Dali::FrameBuffer *)jarg1;
24196   arg2 = (Dali::Texture *)jarg2;
24197   if (!arg2) {
24198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24199     return ;
24200   }
24201   {
24202     try {
24203       (arg1)->AttachColorTexture(*arg2);
24204     } catch (std::out_of_range& e) {
24205       {
24206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24207       };
24208     } catch (std::exception& e) {
24209       {
24210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24211       };
24212     } catch (...) {
24213       {
24214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24215       };
24216     }
24217   }
24218 }
24219
24220
24221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24222   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24223   Dali::Texture *arg2 = 0 ;
24224   unsigned int arg3 ;
24225   unsigned int arg4 ;
24226
24227   arg1 = (Dali::FrameBuffer *)jarg1;
24228   arg2 = (Dali::Texture *)jarg2;
24229   if (!arg2) {
24230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24231     return ;
24232   }
24233   arg3 = (unsigned int)jarg3;
24234   arg4 = (unsigned int)jarg4;
24235   {
24236     try {
24237       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24238     } catch (std::out_of_range& e) {
24239       {
24240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24241       };
24242     } catch (std::exception& e) {
24243       {
24244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24245       };
24246     } catch (...) {
24247       {
24248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24249       };
24250     }
24251   }
24252 }
24253
24254
24255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24256   void * jresult ;
24257   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24258   Dali::Texture result;
24259
24260   arg1 = (Dali::FrameBuffer *)jarg1;
24261   {
24262     try {
24263       result = (arg1)->GetColorTexture();
24264     } catch (std::out_of_range& e) {
24265       {
24266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24267       };
24268     } catch (std::exception& e) {
24269       {
24270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24271       };
24272     } catch (...) {
24273       {
24274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24275       };
24276     }
24277   }
24278   jresult = new Dali::Texture((const Dali::Texture &)result);
24279   return jresult;
24280 }
24281
24282
24283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24284   void * jresult ;
24285   Dali::RenderTaskList *result = 0 ;
24286
24287   {
24288     try {
24289       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24290     } catch (std::out_of_range& e) {
24291       {
24292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24293       };
24294     } catch (std::exception& e) {
24295       {
24296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24297       };
24298     } catch (...) {
24299       {
24300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24301       };
24302     }
24303   }
24304   jresult = (void *)result;
24305   return jresult;
24306 }
24307
24308
24309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24310   void * jresult ;
24311   Dali::BaseHandle arg1 ;
24312   Dali::BaseHandle *argp1 ;
24313   Dali::RenderTaskList result;
24314
24315   argp1 = (Dali::BaseHandle *)jarg1;
24316   if (!argp1) {
24317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24318     return 0;
24319   }
24320   arg1 = *argp1;
24321   {
24322     try {
24323       result = Dali::RenderTaskList::DownCast(arg1);
24324     } catch (std::out_of_range& e) {
24325       {
24326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24327       };
24328     } catch (std::exception& e) {
24329       {
24330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24331       };
24332     } catch (...) {
24333       {
24334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24335       };
24336     }
24337   }
24338   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24339   return jresult;
24340 }
24341
24342
24343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24344   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24345
24346   arg1 = (Dali::RenderTaskList *)jarg1;
24347   {
24348     try {
24349       delete arg1;
24350     } catch (std::out_of_range& e) {
24351       {
24352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24353       };
24354     } catch (std::exception& e) {
24355       {
24356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24357       };
24358     } catch (...) {
24359       {
24360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24361       };
24362     }
24363   }
24364 }
24365
24366
24367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24368   void * jresult ;
24369   Dali::RenderTaskList *arg1 = 0 ;
24370   Dali::RenderTaskList *result = 0 ;
24371
24372   arg1 = (Dali::RenderTaskList *)jarg1;
24373   if (!arg1) {
24374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24375     return 0;
24376   }
24377   {
24378     try {
24379       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24380     } catch (std::out_of_range& e) {
24381       {
24382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24383       };
24384     } catch (std::exception& e) {
24385       {
24386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24387       };
24388     } catch (...) {
24389       {
24390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24391       };
24392     }
24393   }
24394   jresult = (void *)result;
24395   return jresult;
24396 }
24397
24398
24399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24400   void * jresult ;
24401   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24402   Dali::RenderTaskList *arg2 = 0 ;
24403   Dali::RenderTaskList *result = 0 ;
24404
24405   arg1 = (Dali::RenderTaskList *)jarg1;
24406   arg2 = (Dali::RenderTaskList *)jarg2;
24407   if (!arg2) {
24408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24409     return 0;
24410   }
24411   {
24412     try {
24413       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24414     } catch (std::out_of_range& e) {
24415       {
24416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24417       };
24418     } catch (std::exception& e) {
24419       {
24420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24421       };
24422     } catch (...) {
24423       {
24424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24425       };
24426     }
24427   }
24428   jresult = (void *)result;
24429   return jresult;
24430 }
24431
24432
24433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24434   void * jresult ;
24435   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24436   Dali::RenderTask result;
24437
24438   arg1 = (Dali::RenderTaskList *)jarg1;
24439   {
24440     try {
24441       result = (arg1)->CreateTask();
24442     } catch (std::out_of_range& e) {
24443       {
24444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24445       };
24446     } catch (std::exception& e) {
24447       {
24448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24449       };
24450     } catch (...) {
24451       {
24452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24453       };
24454     }
24455   }
24456   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24457   return jresult;
24458 }
24459
24460
24461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24462   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24463   Dali::RenderTask arg2 ;
24464   Dali::RenderTask *argp2 ;
24465
24466   arg1 = (Dali::RenderTaskList *)jarg1;
24467   argp2 = (Dali::RenderTask *)jarg2;
24468   if (!argp2) {
24469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24470     return ;
24471   }
24472   arg2 = *argp2;
24473   {
24474     try {
24475       (arg1)->RemoveTask(arg2);
24476     } catch (std::out_of_range& e) {
24477       {
24478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24479       };
24480     } catch (std::exception& e) {
24481       {
24482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24483       };
24484     } catch (...) {
24485       {
24486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24487       };
24488     }
24489   }
24490 }
24491
24492
24493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24494   unsigned int jresult ;
24495   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24496   unsigned int result;
24497
24498   arg1 = (Dali::RenderTaskList *)jarg1;
24499   {
24500     try {
24501       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24502     } catch (std::out_of_range& e) {
24503       {
24504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24505       };
24506     } catch (std::exception& e) {
24507       {
24508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24509       };
24510     } catch (...) {
24511       {
24512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24513       };
24514     }
24515   }
24516   jresult = result;
24517   return jresult;
24518 }
24519
24520
24521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24522   void * jresult ;
24523   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24524   unsigned int arg2 ;
24525   Dali::RenderTask result;
24526
24527   arg1 = (Dali::RenderTaskList *)jarg1;
24528   arg2 = (unsigned int)jarg2;
24529   {
24530     try {
24531       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24532     } catch (std::out_of_range& e) {
24533       {
24534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (std::exception& e) {
24537       {
24538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24539       };
24540     } catch (...) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24543       };
24544     }
24545   }
24546   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24547   return jresult;
24548 }
24549
24550
24551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24552   int jresult ;
24553   int result;
24554
24555   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24556   jresult = (int)result;
24557   return jresult;
24558 }
24559
24560
24561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24562   int jresult ;
24563   int result;
24564
24565   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24566   jresult = (int)result;
24567   return jresult;
24568 }
24569
24570
24571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24572   int jresult ;
24573   int result;
24574
24575   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24576   jresult = (int)result;
24577   return jresult;
24578 }
24579
24580
24581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24582   int jresult ;
24583   int result;
24584
24585   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24586   jresult = (int)result;
24587   return jresult;
24588 }
24589
24590
24591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24592   void * jresult ;
24593   Dali::RenderTask::Property *result = 0 ;
24594
24595   {
24596     try {
24597       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24598     } catch (std::out_of_range& e) {
24599       {
24600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24601       };
24602     } catch (std::exception& e) {
24603       {
24604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24605       };
24606     } catch (...) {
24607       {
24608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24609       };
24610     }
24611   }
24612   jresult = (void *)result;
24613   return jresult;
24614 }
24615
24616
24617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24618   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24619
24620   arg1 = (Dali::RenderTask::Property *)jarg1;
24621   {
24622     try {
24623       delete arg1;
24624     } catch (std::out_of_range& e) {
24625       {
24626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24627       };
24628     } catch (std::exception& e) {
24629       {
24630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24631       };
24632     } catch (...) {
24633       {
24634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24635       };
24636     }
24637   }
24638 }
24639
24640
24641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24642   void * jresult ;
24643   bool (*result)(Dali::Vector2 &) = 0 ;
24644
24645   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24646   jresult = (void *)result;
24647   return jresult;
24648 }
24649
24650
24651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24652   void * jresult ;
24653   bool (*result)(Dali::Vector2 &) = 0 ;
24654
24655   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24656   jresult = (void *)result;
24657   return jresult;
24658 }
24659
24660
24661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24662   unsigned int jresult ;
24663   bool result;
24664
24665   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24666   jresult = result;
24667   return jresult;
24668 }
24669
24670
24671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24672   unsigned int jresult ;
24673   bool result;
24674
24675   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24676   jresult = result;
24677   return jresult;
24678 }
24679
24680
24681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24682   void * jresult ;
24683   Dali::Vector4 *result = 0 ;
24684
24685   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24686   jresult = (void *)result;
24687   return jresult;
24688 }
24689
24690
24691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24692   unsigned int jresult ;
24693   bool result;
24694
24695   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24696   jresult = result;
24697   return jresult;
24698 }
24699
24700
24701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24702   unsigned int jresult ;
24703   bool result;
24704
24705   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24706   jresult = result;
24707   return jresult;
24708 }
24709
24710
24711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24712   unsigned int jresult ;
24713   unsigned int result;
24714
24715   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24716   jresult = result;
24717   return jresult;
24718 }
24719
24720
24721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24722   void * jresult ;
24723   Dali::RenderTask *result = 0 ;
24724
24725   {
24726     try {
24727       result = (Dali::RenderTask *)new Dali::RenderTask();
24728     } catch (std::out_of_range& e) {
24729       {
24730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24731       };
24732     } catch (std::exception& e) {
24733       {
24734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24735       };
24736     } catch (...) {
24737       {
24738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24739       };
24740     }
24741   }
24742   jresult = (void *)result;
24743   return jresult;
24744 }
24745
24746
24747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24748   void * jresult ;
24749   Dali::BaseHandle arg1 ;
24750   Dali::BaseHandle *argp1 ;
24751   Dali::RenderTask result;
24752
24753   argp1 = (Dali::BaseHandle *)jarg1;
24754   if (!argp1) {
24755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24756     return 0;
24757   }
24758   arg1 = *argp1;
24759   {
24760     try {
24761       result = Dali::RenderTask::DownCast(arg1);
24762     } catch (std::out_of_range& e) {
24763       {
24764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24765       };
24766     } catch (std::exception& e) {
24767       {
24768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24769       };
24770     } catch (...) {
24771       {
24772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24773       };
24774     }
24775   }
24776   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24777   return jresult;
24778 }
24779
24780
24781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24782   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24783
24784   arg1 = (Dali::RenderTask *)jarg1;
24785   {
24786     try {
24787       delete arg1;
24788     } catch (std::out_of_range& e) {
24789       {
24790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24791       };
24792     } catch (std::exception& e) {
24793       {
24794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24795       };
24796     } catch (...) {
24797       {
24798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24799       };
24800     }
24801   }
24802 }
24803
24804
24805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24806   void * jresult ;
24807   Dali::RenderTask *arg1 = 0 ;
24808   Dali::RenderTask *result = 0 ;
24809
24810   arg1 = (Dali::RenderTask *)jarg1;
24811   if (!arg1) {
24812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24813     return 0;
24814   }
24815   {
24816     try {
24817       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24818     } catch (std::out_of_range& e) {
24819       {
24820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24821       };
24822     } catch (std::exception& e) {
24823       {
24824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24825       };
24826     } catch (...) {
24827       {
24828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24829       };
24830     }
24831   }
24832   jresult = (void *)result;
24833   return jresult;
24834 }
24835
24836
24837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24838   void * jresult ;
24839   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24840   Dali::RenderTask *arg2 = 0 ;
24841   Dali::RenderTask *result = 0 ;
24842
24843   arg1 = (Dali::RenderTask *)jarg1;
24844   arg2 = (Dali::RenderTask *)jarg2;
24845   if (!arg2) {
24846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24847     return 0;
24848   }
24849   {
24850     try {
24851       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24852     } catch (std::out_of_range& e) {
24853       {
24854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24855       };
24856     } catch (std::exception& e) {
24857       {
24858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24859       };
24860     } catch (...) {
24861       {
24862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24863       };
24864     }
24865   }
24866   jresult = (void *)result;
24867   return jresult;
24868 }
24869
24870
24871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24872   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24873   Dali::Actor arg2 ;
24874   Dali::Actor *argp2 ;
24875
24876   arg1 = (Dali::RenderTask *)jarg1;
24877   argp2 = (Dali::Actor *)jarg2;
24878   if (!argp2) {
24879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24880     return ;
24881   }
24882   arg2 = *argp2;
24883   {
24884     try {
24885       (arg1)->SetSourceActor(arg2);
24886     } catch (std::out_of_range& e) {
24887       {
24888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24889       };
24890     } catch (std::exception& e) {
24891       {
24892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24893       };
24894     } catch (...) {
24895       {
24896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24897       };
24898     }
24899   }
24900 }
24901
24902
24903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24904   void * jresult ;
24905   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24906   Dali::Actor result;
24907
24908   arg1 = (Dali::RenderTask *)jarg1;
24909   {
24910     try {
24911       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24912     } catch (std::out_of_range& e) {
24913       {
24914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24915       };
24916     } catch (std::exception& e) {
24917       {
24918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24919       };
24920     } catch (...) {
24921       {
24922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24923       };
24924     }
24925   }
24926   jresult = new Dali::Actor((const Dali::Actor &)result);
24927   return jresult;
24928 }
24929
24930
24931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24932   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24933   bool arg2 ;
24934
24935   arg1 = (Dali::RenderTask *)jarg1;
24936   arg2 = jarg2 ? true : false;
24937   {
24938     try {
24939       (arg1)->SetExclusive(arg2);
24940     } catch (std::out_of_range& e) {
24941       {
24942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24943       };
24944     } catch (std::exception& e) {
24945       {
24946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24947       };
24948     } catch (...) {
24949       {
24950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24951       };
24952     }
24953   }
24954 }
24955
24956
24957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24958   unsigned int jresult ;
24959   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24960   bool result;
24961
24962   arg1 = (Dali::RenderTask *)jarg1;
24963   {
24964     try {
24965       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24966     } catch (std::out_of_range& e) {
24967       {
24968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24969       };
24970     } catch (std::exception& e) {
24971       {
24972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24973       };
24974     } catch (...) {
24975       {
24976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24977       };
24978     }
24979   }
24980   jresult = result;
24981   return jresult;
24982 }
24983
24984
24985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
24986   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24987   bool arg2 ;
24988
24989   arg1 = (Dali::RenderTask *)jarg1;
24990   arg2 = jarg2 ? true : false;
24991   {
24992     try {
24993       (arg1)->SetInputEnabled(arg2);
24994     } catch (std::out_of_range& e) {
24995       {
24996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24997       };
24998     } catch (std::exception& e) {
24999       {
25000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25001       };
25002     } catch (...) {
25003       {
25004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25005       };
25006     }
25007   }
25008 }
25009
25010
25011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25012   unsigned int jresult ;
25013   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25014   bool result;
25015
25016   arg1 = (Dali::RenderTask *)jarg1;
25017   {
25018     try {
25019       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25020     } catch (std::out_of_range& e) {
25021       {
25022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25023       };
25024     } catch (std::exception& e) {
25025       {
25026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25027       };
25028     } catch (...) {
25029       {
25030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25031       };
25032     }
25033   }
25034   jresult = result;
25035   return jresult;
25036 }
25037
25038
25039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25040   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25041   Dali::CameraActor arg2 ;
25042   Dali::CameraActor *argp2 ;
25043
25044   arg1 = (Dali::RenderTask *)jarg1;
25045   argp2 = (Dali::CameraActor *)jarg2;
25046   if (!argp2) {
25047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25048     return ;
25049   }
25050   arg2 = *argp2;
25051   {
25052     try {
25053       (arg1)->SetCameraActor(arg2);
25054     } catch (std::out_of_range& e) {
25055       {
25056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25057       };
25058     } catch (std::exception& e) {
25059       {
25060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25061       };
25062     } catch (...) {
25063       {
25064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25065       };
25066     }
25067   }
25068 }
25069
25070
25071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25072   void * jresult ;
25073   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25074   Dali::CameraActor result;
25075
25076   arg1 = (Dali::RenderTask *)jarg1;
25077   {
25078     try {
25079       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25080     } catch (std::out_of_range& e) {
25081       {
25082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25083       };
25084     } catch (std::exception& e) {
25085       {
25086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25087       };
25088     } catch (...) {
25089       {
25090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25091       };
25092     }
25093   }
25094   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25095   return jresult;
25096 }
25097
25098
25099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25100   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25101   Dali::FrameBufferImage arg2 ;
25102   Dali::FrameBufferImage *argp2 ;
25103
25104   arg1 = (Dali::RenderTask *)jarg1;
25105   argp2 = (Dali::FrameBufferImage *)jarg2;
25106   if (!argp2) {
25107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25108     return ;
25109   }
25110   arg2 = *argp2;
25111   {
25112     try {
25113       (arg1)->SetTargetFrameBuffer(arg2);
25114     } catch (std::out_of_range& e) {
25115       {
25116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25117       };
25118     } catch (std::exception& e) {
25119       {
25120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25121       };
25122     } catch (...) {
25123       {
25124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25125       };
25126     }
25127   }
25128 }
25129
25130
25131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25132   void * jresult ;
25133   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25134   Dali::FrameBufferImage result;
25135
25136   arg1 = (Dali::RenderTask *)jarg1;
25137   {
25138     try {
25139       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25140     } catch (std::out_of_range& e) {
25141       {
25142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25143       };
25144     } catch (std::exception& e) {
25145       {
25146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25147       };
25148     } catch (...) {
25149       {
25150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25151       };
25152     }
25153   }
25154   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25155   return jresult;
25156 }
25157
25158
25159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25160   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25161   Dali::FrameBuffer arg2 ;
25162   Dali::FrameBuffer *argp2 ;
25163
25164   arg1 = (Dali::RenderTask *)jarg1;
25165   argp2 = (Dali::FrameBuffer *)jarg2;
25166   if (!argp2) {
25167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25168     return ;
25169   }
25170   arg2 = *argp2;
25171   {
25172     try {
25173       (arg1)->SetFrameBuffer(arg2);
25174     } catch (std::out_of_range& e) {
25175       {
25176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25177       };
25178     } catch (std::exception& e) {
25179       {
25180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25181       };
25182     } catch (...) {
25183       {
25184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25185       };
25186     }
25187   }
25188 }
25189
25190
25191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25192   void * jresult ;
25193   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25194   Dali::FrameBuffer result;
25195
25196   arg1 = (Dali::RenderTask *)jarg1;
25197   {
25198     try {
25199       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25200     } catch (std::out_of_range& e) {
25201       {
25202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25203       };
25204     } catch (std::exception& e) {
25205       {
25206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25207       };
25208     } catch (...) {
25209       {
25210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25211       };
25212     }
25213   }
25214   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25220   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25221   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25222
25223   arg1 = (Dali::RenderTask *)jarg1;
25224   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25225   {
25226     try {
25227       (arg1)->SetScreenToFrameBufferFunction(arg2);
25228     } catch (std::out_of_range& e) {
25229       {
25230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25231       };
25232     } catch (std::exception& e) {
25233       {
25234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25235       };
25236     } catch (...) {
25237       {
25238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25239       };
25240     }
25241   }
25242 }
25243
25244
25245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25246   void * jresult ;
25247   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25248   Dali::RenderTask::ScreenToFrameBufferFunction result;
25249
25250   arg1 = (Dali::RenderTask *)jarg1;
25251   {
25252     try {
25253       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25254     } catch (std::out_of_range& e) {
25255       {
25256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25257       };
25258     } catch (std::exception& e) {
25259       {
25260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25261       };
25262     } catch (...) {
25263       {
25264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25265       };
25266     }
25267   }
25268   jresult = (void *)result;
25269   return jresult;
25270 }
25271
25272
25273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25274   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25275   Dali::Actor arg2 ;
25276   Dali::Actor *argp2 ;
25277
25278   arg1 = (Dali::RenderTask *)jarg1;
25279   argp2 = (Dali::Actor *)jarg2;
25280   if (!argp2) {
25281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25282     return ;
25283   }
25284   arg2 = *argp2;
25285   {
25286     try {
25287       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25288     } catch (std::out_of_range& e) {
25289       {
25290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25291       };
25292     } catch (std::exception& e) {
25293       {
25294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25295       };
25296     } catch (...) {
25297       {
25298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25299       };
25300     }
25301   }
25302 }
25303
25304
25305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25306   void * jresult ;
25307   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25308   Dali::Actor result;
25309
25310   arg1 = (Dali::RenderTask *)jarg1;
25311   {
25312     try {
25313       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25314     } catch (std::out_of_range& e) {
25315       {
25316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25317       };
25318     } catch (std::exception& e) {
25319       {
25320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25321       };
25322     } catch (...) {
25323       {
25324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25325       };
25326     }
25327   }
25328   jresult = new Dali::Actor((const Dali::Actor &)result);
25329   return jresult;
25330 }
25331
25332
25333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25334   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25335   Dali::Vector2 arg2 ;
25336   Dali::Vector2 *argp2 ;
25337
25338   arg1 = (Dali::RenderTask *)jarg1;
25339   argp2 = (Dali::Vector2 *)jarg2;
25340   if (!argp2) {
25341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25342     return ;
25343   }
25344   arg2 = *argp2;
25345   {
25346     try {
25347       (arg1)->SetViewportPosition(arg2);
25348     } catch (std::out_of_range& e) {
25349       {
25350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25351       };
25352     } catch (std::exception& e) {
25353       {
25354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25355       };
25356     } catch (...) {
25357       {
25358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25359       };
25360     }
25361   }
25362 }
25363
25364
25365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25366   void * jresult ;
25367   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25368   Dali::Vector2 result;
25369
25370   arg1 = (Dali::RenderTask *)jarg1;
25371   {
25372     try {
25373       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25374     } catch (std::out_of_range& e) {
25375       {
25376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25377       };
25378     } catch (std::exception& e) {
25379       {
25380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25381       };
25382     } catch (...) {
25383       {
25384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25385       };
25386     }
25387   }
25388   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25389   return jresult;
25390 }
25391
25392
25393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25394   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25395   Dali::Vector2 arg2 ;
25396   Dali::Vector2 *argp2 ;
25397
25398   arg1 = (Dali::RenderTask *)jarg1;
25399   argp2 = (Dali::Vector2 *)jarg2;
25400   if (!argp2) {
25401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25402     return ;
25403   }
25404   arg2 = *argp2;
25405   {
25406     try {
25407       (arg1)->SetViewportSize(arg2);
25408     } catch (std::out_of_range& e) {
25409       {
25410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25411       };
25412     } catch (std::exception& e) {
25413       {
25414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25415       };
25416     } catch (...) {
25417       {
25418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25419       };
25420     }
25421   }
25422 }
25423
25424
25425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25426   void * jresult ;
25427   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25428   Dali::Vector2 result;
25429
25430   arg1 = (Dali::RenderTask *)jarg1;
25431   {
25432     try {
25433       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25434     } catch (std::out_of_range& e) {
25435       {
25436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25437       };
25438     } catch (std::exception& e) {
25439       {
25440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25441       };
25442     } catch (...) {
25443       {
25444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25445       };
25446     }
25447   }
25448   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25449   return jresult;
25450 }
25451
25452
25453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25454   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25455   Dali::Viewport arg2 ;
25456   Dali::Viewport *argp2 ;
25457
25458   arg1 = (Dali::RenderTask *)jarg1;
25459   argp2 = (Dali::Viewport *)jarg2;
25460   if (!argp2) {
25461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25462     return ;
25463   }
25464   arg2 = *argp2;
25465   {
25466     try {
25467       (arg1)->SetViewport(arg2);
25468     } catch (std::out_of_range& e) {
25469       {
25470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25471       };
25472     } catch (std::exception& e) {
25473       {
25474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25475       };
25476     } catch (...) {
25477       {
25478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25479       };
25480     }
25481   }
25482 }
25483
25484
25485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25486   void * jresult ;
25487   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25488   Dali::Viewport result;
25489
25490   arg1 = (Dali::RenderTask *)jarg1;
25491   {
25492     try {
25493       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25494     } catch (std::out_of_range& e) {
25495       {
25496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25497       };
25498     } catch (std::exception& e) {
25499       {
25500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25501       };
25502     } catch (...) {
25503       {
25504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25505       };
25506     }
25507   }
25508   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25509   return jresult;
25510 }
25511
25512
25513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25514   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25515   Dali::Vector4 *arg2 = 0 ;
25516
25517   arg1 = (Dali::RenderTask *)jarg1;
25518   arg2 = (Dali::Vector4 *)jarg2;
25519   if (!arg2) {
25520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25521     return ;
25522   }
25523   {
25524     try {
25525       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25526     } catch (std::out_of_range& e) {
25527       {
25528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25529       };
25530     } catch (std::exception& e) {
25531       {
25532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25533       };
25534     } catch (...) {
25535       {
25536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25537       };
25538     }
25539   }
25540 }
25541
25542
25543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25544   void * jresult ;
25545   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25546   Dali::Vector4 result;
25547
25548   arg1 = (Dali::RenderTask *)jarg1;
25549   {
25550     try {
25551       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25552     } catch (std::out_of_range& e) {
25553       {
25554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25555       };
25556     } catch (std::exception& e) {
25557       {
25558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25559       };
25560     } catch (...) {
25561       {
25562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25563       };
25564     }
25565   }
25566   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25567   return jresult;
25568 }
25569
25570
25571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25572   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25573   bool arg2 ;
25574
25575   arg1 = (Dali::RenderTask *)jarg1;
25576   arg2 = jarg2 ? true : false;
25577   {
25578     try {
25579       (arg1)->SetClearEnabled(arg2);
25580     } catch (std::out_of_range& e) {
25581       {
25582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25583       };
25584     } catch (std::exception& e) {
25585       {
25586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25587       };
25588     } catch (...) {
25589       {
25590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25591       };
25592     }
25593   }
25594 }
25595
25596
25597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25598   unsigned int jresult ;
25599   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25600   bool result;
25601
25602   arg1 = (Dali::RenderTask *)jarg1;
25603   {
25604     try {
25605       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25606     } catch (std::out_of_range& e) {
25607       {
25608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25609       };
25610     } catch (std::exception& e) {
25611       {
25612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25613       };
25614     } catch (...) {
25615       {
25616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25617       };
25618     }
25619   }
25620   jresult = result;
25621   return jresult;
25622 }
25623
25624
25625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25626   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25627   bool arg2 ;
25628
25629   arg1 = (Dali::RenderTask *)jarg1;
25630   arg2 = jarg2 ? true : false;
25631   {
25632     try {
25633       (arg1)->SetCullMode(arg2);
25634     } catch (std::out_of_range& e) {
25635       {
25636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25637       };
25638     } catch (std::exception& e) {
25639       {
25640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25641       };
25642     } catch (...) {
25643       {
25644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25645       };
25646     }
25647   }
25648 }
25649
25650
25651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25652   unsigned int jresult ;
25653   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25654   bool result;
25655
25656   arg1 = (Dali::RenderTask *)jarg1;
25657   {
25658     try {
25659       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25660     } catch (std::out_of_range& e) {
25661       {
25662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25663       };
25664     } catch (std::exception& e) {
25665       {
25666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25667       };
25668     } catch (...) {
25669       {
25670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25671       };
25672     }
25673   }
25674   jresult = result;
25675   return jresult;
25676 }
25677
25678
25679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25680   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25681   unsigned int arg2 ;
25682
25683   arg1 = (Dali::RenderTask *)jarg1;
25684   arg2 = (unsigned int)jarg2;
25685   {
25686     try {
25687       (arg1)->SetRefreshRate(arg2);
25688     } catch (std::out_of_range& e) {
25689       {
25690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25691       };
25692     } catch (std::exception& e) {
25693       {
25694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25695       };
25696     } catch (...) {
25697       {
25698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25699       };
25700     }
25701   }
25702 }
25703
25704
25705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25706   unsigned int jresult ;
25707   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25708   unsigned int result;
25709
25710   arg1 = (Dali::RenderTask *)jarg1;
25711   {
25712     try {
25713       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25714     } catch (std::out_of_range& e) {
25715       {
25716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25717       };
25718     } catch (std::exception& e) {
25719       {
25720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25721       };
25722     } catch (...) {
25723       {
25724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25725       };
25726     }
25727   }
25728   jresult = result;
25729   return jresult;
25730 }
25731
25732
25733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25734   unsigned int jresult ;
25735   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25736   Dali::Vector3 *arg2 = 0 ;
25737   float *arg3 = 0 ;
25738   float *arg4 = 0 ;
25739   bool result;
25740
25741   arg1 = (Dali::RenderTask *)jarg1;
25742   arg2 = (Dali::Vector3 *)jarg2;
25743   if (!arg2) {
25744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25745     return 0;
25746   }
25747   arg3 = (float *)jarg3;
25748   arg4 = (float *)jarg4;
25749   {
25750     try {
25751       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25752     } catch (std::out_of_range& e) {
25753       {
25754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (std::exception& e) {
25757       {
25758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25759       };
25760     } catch (...) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25763       };
25764     }
25765   }
25766   jresult = result;
25767   return jresult;
25768 }
25769
25770
25771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25772   unsigned int jresult ;
25773   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25774   Dali::Actor arg2 ;
25775   float arg3 ;
25776   float arg4 ;
25777   float *arg5 = 0 ;
25778   float *arg6 = 0 ;
25779   Dali::Actor *argp2 ;
25780   bool result;
25781
25782   arg1 = (Dali::RenderTask *)jarg1;
25783   argp2 = (Dali::Actor *)jarg2;
25784   if (!argp2) {
25785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25786     return 0;
25787   }
25788   arg2 = *argp2;
25789   arg3 = (float)jarg3;
25790   arg4 = (float)jarg4;
25791   arg5 = (float *)jarg5;
25792   arg6 = (float *)jarg6;
25793   {
25794     try {
25795       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25796     } catch (std::out_of_range& e) {
25797       {
25798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25799       };
25800     } catch (std::exception& e) {
25801       {
25802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25803       };
25804     } catch (...) {
25805       {
25806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25807       };
25808     }
25809   }
25810   jresult = result;
25811   return jresult;
25812 }
25813
25814
25815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25816   void * jresult ;
25817   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25818   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25819
25820   arg1 = (Dali::RenderTask *)jarg1;
25821   {
25822     try {
25823       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25824     } catch (std::out_of_range& e) {
25825       {
25826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25827       };
25828     } catch (std::exception& e) {
25829       {
25830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25831       };
25832     } catch (...) {
25833       {
25834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25835       };
25836     }
25837   }
25838   jresult = (void *)result;
25839   return jresult;
25840 }
25841
25842
25843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25844   void * jresult ;
25845   int arg1 ;
25846   Dali::TouchPoint::State arg2 ;
25847   float arg3 ;
25848   float arg4 ;
25849   Dali::TouchPoint *result = 0 ;
25850
25851   arg1 = (int)jarg1;
25852   arg2 = (Dali::TouchPoint::State)jarg2;
25853   arg3 = (float)jarg3;
25854   arg4 = (float)jarg4;
25855   {
25856     try {
25857       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25858     } catch (std::out_of_range& e) {
25859       {
25860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25861       };
25862     } catch (std::exception& e) {
25863       {
25864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25865       };
25866     } catch (...) {
25867       {
25868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25869       };
25870     }
25871   }
25872   jresult = (void *)result;
25873   return jresult;
25874 }
25875
25876
25877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25878   void * jresult ;
25879   int arg1 ;
25880   Dali::TouchPoint::State arg2 ;
25881   float arg3 ;
25882   float arg4 ;
25883   float arg5 ;
25884   float arg6 ;
25885   Dali::TouchPoint *result = 0 ;
25886
25887   arg1 = (int)jarg1;
25888   arg2 = (Dali::TouchPoint::State)jarg2;
25889   arg3 = (float)jarg3;
25890   arg4 = (float)jarg4;
25891   arg5 = (float)jarg5;
25892   arg6 = (float)jarg6;
25893   {
25894     try {
25895       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25896     } catch (std::out_of_range& e) {
25897       {
25898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (std::exception& e) {
25901       {
25902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25903       };
25904     } catch (...) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25907       };
25908     }
25909   }
25910   jresult = (void *)result;
25911   return jresult;
25912 }
25913
25914
25915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25916   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25917
25918   arg1 = (Dali::TouchPoint *)jarg1;
25919   {
25920     try {
25921       delete arg1;
25922     } catch (std::out_of_range& e) {
25923       {
25924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25925       };
25926     } catch (std::exception& e) {
25927       {
25928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25929       };
25930     } catch (...) {
25931       {
25932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25933       };
25934     }
25935   }
25936 }
25937
25938
25939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25940   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25941   int arg2 ;
25942
25943   arg1 = (Dali::TouchPoint *)jarg1;
25944   arg2 = (int)jarg2;
25945   if (arg1) (arg1)->deviceId = arg2;
25946 }
25947
25948
25949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25950   int jresult ;
25951   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25952   int result;
25953
25954   arg1 = (Dali::TouchPoint *)jarg1;
25955   result = (int) ((arg1)->deviceId);
25956   jresult = result;
25957   return jresult;
25958 }
25959
25960
25961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25962   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25963   Dali::TouchPoint::State arg2 ;
25964
25965   arg1 = (Dali::TouchPoint *)jarg1;
25966   arg2 = (Dali::TouchPoint::State)jarg2;
25967   if (arg1) (arg1)->state = arg2;
25968 }
25969
25970
25971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25972   int jresult ;
25973   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25974   Dali::TouchPoint::State result;
25975
25976   arg1 = (Dali::TouchPoint *)jarg1;
25977   result = (Dali::TouchPoint::State) ((arg1)->state);
25978   jresult = (int)result;
25979   return jresult;
25980 }
25981
25982
25983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
25984   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25985   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25986
25987   arg1 = (Dali::TouchPoint *)jarg1;
25988   arg2 = (Dali::Actor *)jarg2;
25989   if (arg1) (arg1)->hitActor = *arg2;
25990 }
25991
25992
25993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
25994   void * jresult ;
25995   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25996   Dali::Actor *result = 0 ;
25997
25998   arg1 = (Dali::TouchPoint *)jarg1;
25999   result = (Dali::Actor *)& ((arg1)->hitActor);
26000   jresult = (void *)result;
26001   return jresult;
26002 }
26003
26004
26005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26006   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26007   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26008
26009   arg1 = (Dali::TouchPoint *)jarg1;
26010   arg2 = (Dali::Vector2 *)jarg2;
26011   if (arg1) (arg1)->local = *arg2;
26012 }
26013
26014
26015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26016   void * jresult ;
26017   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26018   Dali::Vector2 *result = 0 ;
26019
26020   arg1 = (Dali::TouchPoint *)jarg1;
26021   result = (Dali::Vector2 *)& ((arg1)->local);
26022   jresult = (void *)result;
26023   return jresult;
26024 }
26025
26026
26027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26028   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26029   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26030
26031   arg1 = (Dali::TouchPoint *)jarg1;
26032   arg2 = (Dali::Vector2 *)jarg2;
26033   if (arg1) (arg1)->screen = *arg2;
26034 }
26035
26036
26037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26038   void * jresult ;
26039   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26040   Dali::Vector2 *result = 0 ;
26041
26042   arg1 = (Dali::TouchPoint *)jarg1;
26043   result = (Dali::Vector2 *)& ((arg1)->screen);
26044   jresult = (void *)result;
26045   return jresult;
26046 }
26047
26048
26049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26050   void * jresult ;
26051   Dali::TouchData *result = 0 ;
26052
26053   {
26054     try {
26055       result = (Dali::TouchData *)new Dali::TouchData();
26056     } catch (std::out_of_range& e) {
26057       {
26058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26059       };
26060     } catch (std::exception& e) {
26061       {
26062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26063       };
26064     } catch (...) {
26065       {
26066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26067       };
26068     }
26069   }
26070   jresult = (void *)result;
26071   return jresult;
26072 }
26073
26074
26075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26076   void * jresult ;
26077   Dali::TouchData *arg1 = 0 ;
26078   Dali::TouchData *result = 0 ;
26079
26080   arg1 = (Dali::TouchData *)jarg1;
26081   if (!arg1) {
26082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26083     return 0;
26084   }
26085   {
26086     try {
26087       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26088     } catch (std::out_of_range& e) {
26089       {
26090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26091       };
26092     } catch (std::exception& e) {
26093       {
26094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26095       };
26096     } catch (...) {
26097       {
26098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26099       };
26100     }
26101   }
26102   jresult = (void *)result;
26103   return jresult;
26104 }
26105
26106
26107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26108   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26109
26110   arg1 = (Dali::TouchData *)jarg1;
26111   {
26112     try {
26113       delete arg1;
26114     } catch (std::out_of_range& e) {
26115       {
26116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26117       };
26118     } catch (std::exception& e) {
26119       {
26120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26121       };
26122     } catch (...) {
26123       {
26124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26125       };
26126     }
26127   }
26128 }
26129
26130
26131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26132   void * jresult ;
26133   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26134   Dali::TouchData *arg2 = 0 ;
26135   Dali::TouchData *result = 0 ;
26136
26137   arg1 = (Dali::TouchData *)jarg1;
26138   arg2 = (Dali::TouchData *)jarg2;
26139   if (!arg2) {
26140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26141     return 0;
26142   }
26143   {
26144     try {
26145       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26146     } catch (std::out_of_range& e) {
26147       {
26148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26149       };
26150     } catch (std::exception& e) {
26151       {
26152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26153       };
26154     } catch (...) {
26155       {
26156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26157       };
26158     }
26159   }
26160   jresult = (void *)result;
26161   return jresult;
26162 }
26163
26164
26165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26166   unsigned long jresult ;
26167   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26168   unsigned long result;
26169
26170   arg1 = (Dali::TouchData *)jarg1;
26171   {
26172     try {
26173       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26174     } catch (std::out_of_range& e) {
26175       {
26176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26177       };
26178     } catch (std::exception& e) {
26179       {
26180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26181       };
26182     } catch (...) {
26183       {
26184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26185       };
26186     }
26187   }
26188   jresult = (unsigned long)result;
26189   return jresult;
26190 }
26191
26192
26193 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26194   unsigned long jresult ;
26195   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26196   std::size_t result;
26197
26198   arg1 = (Dali::TouchData *)jarg1;
26199   {
26200     try {
26201       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26202     } catch (std::out_of_range& e) {
26203       {
26204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (std::exception& e) {
26207       {
26208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26209       };
26210     } catch (...) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26213       };
26214     }
26215   }
26216   jresult = (unsigned long)result;
26217   return jresult;
26218 }
26219
26220
26221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26222   int jresult ;
26223   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26224   std::size_t arg2 ;
26225   int32_t result;
26226
26227   arg1 = (Dali::TouchData *)jarg1;
26228   arg2 = (std::size_t)jarg2;
26229   {
26230     try {
26231       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26232     } catch (std::out_of_range& e) {
26233       {
26234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26235       };
26236     } catch (std::exception& e) {
26237       {
26238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26239       };
26240     } catch (...) {
26241       {
26242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26243       };
26244     }
26245   }
26246   jresult = result;
26247   return jresult;
26248 }
26249
26250
26251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26252   int jresult ;
26253   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26254   std::size_t arg2 ;
26255   Dali::PointState::Type result;
26256
26257   arg1 = (Dali::TouchData *)jarg1;
26258   arg2 = (std::size_t)jarg2;
26259   {
26260     try {
26261       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26262     } catch (std::out_of_range& e) {
26263       {
26264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26265       };
26266     } catch (std::exception& e) {
26267       {
26268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26269       };
26270     } catch (...) {
26271       {
26272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26273       };
26274     }
26275   }
26276   jresult = (int)result;
26277   return jresult;
26278 }
26279
26280
26281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26282   void * jresult ;
26283   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26284   std::size_t arg2 ;
26285   Dali::Actor result;
26286
26287   arg1 = (Dali::TouchData *)jarg1;
26288   arg2 = (std::size_t)jarg2;
26289   {
26290     try {
26291       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26292     } catch (std::out_of_range& e) {
26293       {
26294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26295       };
26296     } catch (std::exception& e) {
26297       {
26298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26299       };
26300     } catch (...) {
26301       {
26302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26303       };
26304     }
26305   }
26306   jresult = new Dali::Actor((const Dali::Actor &)result);
26307   return jresult;
26308 }
26309
26310
26311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26312   void * jresult ;
26313   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26314   std::size_t arg2 ;
26315   Dali::Vector2 *result = 0 ;
26316
26317   arg1 = (Dali::TouchData *)jarg1;
26318   arg2 = (std::size_t)jarg2;
26319   {
26320     try {
26321       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26322     } catch (std::out_of_range& e) {
26323       {
26324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26325       };
26326     } catch (std::exception& e) {
26327       {
26328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26329       };
26330     } catch (...) {
26331       {
26332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26333       };
26334     }
26335   }
26336   jresult = (void *)result;
26337   return jresult;
26338 }
26339
26340
26341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26342   void * jresult ;
26343   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26344   std::size_t arg2 ;
26345   Dali::Vector2 *result = 0 ;
26346
26347   arg1 = (Dali::TouchData *)jarg1;
26348   arg2 = (std::size_t)jarg2;
26349   {
26350     try {
26351       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26352     } catch (std::out_of_range& e) {
26353       {
26354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26355       };
26356     } catch (std::exception& e) {
26357       {
26358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26359       };
26360     } catch (...) {
26361       {
26362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26363       };
26364     }
26365   }
26366   jresult = (void *)result;
26367   return jresult;
26368 }
26369
26370
26371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26372   float jresult ;
26373   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26374   std::size_t arg2 ;
26375   float result;
26376
26377   arg1 = (Dali::TouchData *)jarg1;
26378   arg2 = (std::size_t)jarg2;
26379   {
26380     try {
26381       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26382     } catch (std::out_of_range& e) {
26383       {
26384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26385       };
26386     } catch (std::exception& e) {
26387       {
26388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26389       };
26390     } catch (...) {
26391       {
26392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26393       };
26394     }
26395   }
26396   jresult = result;
26397   return jresult;
26398 }
26399
26400
26401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26402   void * jresult ;
26403   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26404   std::size_t arg2 ;
26405   Dali::Vector2 *result = 0 ;
26406
26407   arg1 = (Dali::TouchData *)jarg1;
26408   arg2 = (std::size_t)jarg2;
26409   {
26410     try {
26411       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26412     } catch (std::out_of_range& e) {
26413       {
26414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26415       };
26416     } catch (std::exception& e) {
26417       {
26418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26419       };
26420     } catch (...) {
26421       {
26422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26423       };
26424     }
26425   }
26426   jresult = (void *)result;
26427   return jresult;
26428 }
26429
26430
26431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26432   float jresult ;
26433   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26434   std::size_t arg2 ;
26435   float result;
26436
26437   arg1 = (Dali::TouchData *)jarg1;
26438   arg2 = (std::size_t)jarg2;
26439   {
26440     try {
26441       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26442     } catch (std::out_of_range& e) {
26443       {
26444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26445       };
26446     } catch (std::exception& e) {
26447       {
26448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26449       };
26450     } catch (...) {
26451       {
26452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26453       };
26454     }
26455   }
26456   jresult = result;
26457   return jresult;
26458 }
26459
26460
26461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26462   void * jresult ;
26463   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26464   std::size_t arg2 ;
26465   Dali::Degree result;
26466
26467   arg1 = (Dali::TouchData *)jarg1;
26468   arg2 = (std::size_t)jarg2;
26469   {
26470     try {
26471       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26472     } catch (std::out_of_range& e) {
26473       {
26474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26475       };
26476     } catch (std::exception& e) {
26477       {
26478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26479       };
26480     } catch (...) {
26481       {
26482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26483       };
26484     }
26485   }
26486   jresult = new Dali::Degree((const Dali::Degree &)result);
26487   return jresult;
26488 }
26489
26490
26491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26492   void * jresult ;
26493   Dali::GestureDetector *result = 0 ;
26494
26495   {
26496     try {
26497       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26498     } catch (std::out_of_range& e) {
26499       {
26500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26501       };
26502     } catch (std::exception& e) {
26503       {
26504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26505       };
26506     } catch (...) {
26507       {
26508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26509       };
26510     }
26511   }
26512   jresult = (void *)result;
26513   return jresult;
26514 }
26515
26516
26517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26518   void * jresult ;
26519   Dali::BaseHandle arg1 ;
26520   Dali::BaseHandle *argp1 ;
26521   Dali::GestureDetector result;
26522
26523   argp1 = (Dali::BaseHandle *)jarg1;
26524   if (!argp1) {
26525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26526     return 0;
26527   }
26528   arg1 = *argp1;
26529   {
26530     try {
26531       result = Dali::GestureDetector::DownCast(arg1);
26532     } catch (std::out_of_range& e) {
26533       {
26534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26535       };
26536     } catch (std::exception& e) {
26537       {
26538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26539       };
26540     } catch (...) {
26541       {
26542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26543       };
26544     }
26545   }
26546   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26547   return jresult;
26548 }
26549
26550
26551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26552   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26553
26554   arg1 = (Dali::GestureDetector *)jarg1;
26555   {
26556     try {
26557       delete arg1;
26558     } catch (std::out_of_range& e) {
26559       {
26560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26561       };
26562     } catch (std::exception& e) {
26563       {
26564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26565       };
26566     } catch (...) {
26567       {
26568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26569       };
26570     }
26571   }
26572 }
26573
26574
26575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26576   void * jresult ;
26577   Dali::GestureDetector *arg1 = 0 ;
26578   Dali::GestureDetector *result = 0 ;
26579
26580   arg1 = (Dali::GestureDetector *)jarg1;
26581   if (!arg1) {
26582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26583     return 0;
26584   }
26585   {
26586     try {
26587       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26588     } catch (std::out_of_range& e) {
26589       {
26590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26591       };
26592     } catch (std::exception& e) {
26593       {
26594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26595       };
26596     } catch (...) {
26597       {
26598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26599       };
26600     }
26601   }
26602   jresult = (void *)result;
26603   return jresult;
26604 }
26605
26606
26607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26608   void * jresult ;
26609   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26610   Dali::GestureDetector *arg2 = 0 ;
26611   Dali::GestureDetector *result = 0 ;
26612
26613   arg1 = (Dali::GestureDetector *)jarg1;
26614   arg2 = (Dali::GestureDetector *)jarg2;
26615   if (!arg2) {
26616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26617     return 0;
26618   }
26619   {
26620     try {
26621       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26622     } catch (std::out_of_range& e) {
26623       {
26624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26625       };
26626     } catch (std::exception& e) {
26627       {
26628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26629       };
26630     } catch (...) {
26631       {
26632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26633       };
26634     }
26635   }
26636   jresult = (void *)result;
26637   return jresult;
26638 }
26639
26640
26641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26642   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26643   Dali::Actor arg2 ;
26644   Dali::Actor *argp2 ;
26645
26646   arg1 = (Dali::GestureDetector *)jarg1;
26647   argp2 = (Dali::Actor *)jarg2;
26648   if (!argp2) {
26649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26650     return ;
26651   }
26652   arg2 = *argp2;
26653   {
26654     try {
26655       (arg1)->Attach(arg2);
26656     } catch (std::out_of_range& e) {
26657       {
26658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26659       };
26660     } catch (std::exception& e) {
26661       {
26662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26663       };
26664     } catch (...) {
26665       {
26666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26667       };
26668     }
26669   }
26670 }
26671
26672
26673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26674   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26675   Dali::Actor arg2 ;
26676   Dali::Actor *argp2 ;
26677
26678   arg1 = (Dali::GestureDetector *)jarg1;
26679   argp2 = (Dali::Actor *)jarg2;
26680   if (!argp2) {
26681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26682     return ;
26683   }
26684   arg2 = *argp2;
26685   {
26686     try {
26687       (arg1)->Detach(arg2);
26688     } catch (std::out_of_range& e) {
26689       {
26690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26691       };
26692     } catch (std::exception& e) {
26693       {
26694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26695       };
26696     } catch (...) {
26697       {
26698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26699       };
26700     }
26701   }
26702 }
26703
26704
26705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26706   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26707
26708   arg1 = (Dali::GestureDetector *)jarg1;
26709   {
26710     try {
26711       (arg1)->DetachAll();
26712     } catch (std::out_of_range& e) {
26713       {
26714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26715       };
26716     } catch (std::exception& e) {
26717       {
26718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26719       };
26720     } catch (...) {
26721       {
26722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26723       };
26724     }
26725   }
26726 }
26727
26728
26729 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26730   unsigned long jresult ;
26731   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26732   size_t result;
26733
26734   arg1 = (Dali::GestureDetector *)jarg1;
26735   {
26736     try {
26737       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26738     } catch (std::out_of_range& e) {
26739       {
26740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26741       };
26742     } catch (std::exception& e) {
26743       {
26744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26745       };
26746     } catch (...) {
26747       {
26748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26749       };
26750     }
26751   }
26752   jresult = (unsigned long)result;
26753   return jresult;
26754 }
26755
26756
26757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26758   void * jresult ;
26759   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26760   size_t arg2 ;
26761   Dali::Actor result;
26762
26763   arg1 = (Dali::GestureDetector *)jarg1;
26764   arg2 = (size_t)jarg2;
26765   {
26766     try {
26767       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26768     } catch (std::out_of_range& e) {
26769       {
26770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26771       };
26772     } catch (std::exception& e) {
26773       {
26774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26775       };
26776     } catch (...) {
26777       {
26778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26779       };
26780     }
26781   }
26782   jresult = new Dali::Actor((const Dali::Actor &)result);
26783   return jresult;
26784 }
26785
26786
26787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26788   void * jresult ;
26789   Dali::Gesture *arg1 = 0 ;
26790   Dali::Gesture *result = 0 ;
26791
26792   arg1 = (Dali::Gesture *)jarg1;
26793   if (!arg1) {
26794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26795     return 0;
26796   }
26797   {
26798     try {
26799       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26800     } catch (std::out_of_range& e) {
26801       {
26802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26803       };
26804     } catch (std::exception& e) {
26805       {
26806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26807       };
26808     } catch (...) {
26809       {
26810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26811       };
26812     }
26813   }
26814   jresult = (void *)result;
26815   return jresult;
26816 }
26817
26818
26819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26820   void * jresult ;
26821   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26822   Dali::Gesture *arg2 = 0 ;
26823   Dali::Gesture *result = 0 ;
26824
26825   arg1 = (Dali::Gesture *)jarg1;
26826   arg2 = (Dali::Gesture *)jarg2;
26827   if (!arg2) {
26828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26829     return 0;
26830   }
26831   {
26832     try {
26833       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26834     } catch (std::out_of_range& e) {
26835       {
26836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26837       };
26838     } catch (std::exception& e) {
26839       {
26840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26841       };
26842     } catch (...) {
26843       {
26844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26845       };
26846     }
26847   }
26848   jresult = (void *)result;
26849   return jresult;
26850 }
26851
26852
26853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26854   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26855
26856   arg1 = (Dali::Gesture *)jarg1;
26857   {
26858     try {
26859       delete arg1;
26860     } catch (std::out_of_range& e) {
26861       {
26862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26863       };
26864     } catch (std::exception& e) {
26865       {
26866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26867       };
26868     } catch (...) {
26869       {
26870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26871       };
26872     }
26873   }
26874 }
26875
26876
26877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26878   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26879   Dali::Gesture::Type arg2 ;
26880
26881   arg1 = (Dali::Gesture *)jarg1;
26882   arg2 = (Dali::Gesture::Type)jarg2;
26883   if (arg1) (arg1)->type = arg2;
26884 }
26885
26886
26887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26888   int jresult ;
26889   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26890   Dali::Gesture::Type result;
26891
26892   arg1 = (Dali::Gesture *)jarg1;
26893   result = (Dali::Gesture::Type) ((arg1)->type);
26894   jresult = (int)result;
26895   return jresult;
26896 }
26897
26898
26899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26900   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26901   Dali::Gesture::State arg2 ;
26902
26903   arg1 = (Dali::Gesture *)jarg1;
26904   arg2 = (Dali::Gesture::State)jarg2;
26905   if (arg1) (arg1)->state = arg2;
26906 }
26907
26908
26909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26910   int jresult ;
26911   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26912   Dali::Gesture::State result;
26913
26914   arg1 = (Dali::Gesture *)jarg1;
26915   result = (Dali::Gesture::State) ((arg1)->state);
26916   jresult = (int)result;
26917   return jresult;
26918 }
26919
26920
26921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26922   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26923   unsigned int arg2 ;
26924
26925   arg1 = (Dali::Gesture *)jarg1;
26926   arg2 = (unsigned int)jarg2;
26927   if (arg1) (arg1)->time = arg2;
26928 }
26929
26930
26931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26932   unsigned int jresult ;
26933   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26934   unsigned int result;
26935
26936   arg1 = (Dali::Gesture *)jarg1;
26937   result = (unsigned int) ((arg1)->time);
26938   jresult = result;
26939   return jresult;
26940 }
26941
26942
26943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26944   void * jresult ;
26945   Dali::HoverEvent *result = 0 ;
26946
26947   {
26948     try {
26949       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26950     } catch (std::out_of_range& e) {
26951       {
26952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26953       };
26954     } catch (std::exception& e) {
26955       {
26956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26957       };
26958     } catch (...) {
26959       {
26960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26961       };
26962     }
26963   }
26964   jresult = (void *)result;
26965   return jresult;
26966 }
26967
26968
26969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26970   void * jresult ;
26971   unsigned long arg1 ;
26972   Dali::HoverEvent *result = 0 ;
26973
26974   arg1 = (unsigned long)jarg1;
26975   {
26976     try {
26977       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26978     } catch (std::out_of_range& e) {
26979       {
26980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26981       };
26982     } catch (std::exception& e) {
26983       {
26984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26985       };
26986     } catch (...) {
26987       {
26988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26989       };
26990     }
26991   }
26992   jresult = (void *)result;
26993   return jresult;
26994 }
26995
26996
26997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
26998   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26999
27000   arg1 = (Dali::HoverEvent *)jarg1;
27001   {
27002     try {
27003       delete arg1;
27004     } catch (std::out_of_range& e) {
27005       {
27006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27007       };
27008     } catch (std::exception& e) {
27009       {
27010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27011       };
27012     } catch (...) {
27013       {
27014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27015       };
27016     }
27017   }
27018 }
27019
27020
27021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27022   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27023   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27024
27025   arg1 = (Dali::HoverEvent *)jarg1;
27026   arg2 = (Dali::TouchPointContainer *)jarg2;
27027   if (arg1) (arg1)->points = *arg2;
27028 }
27029
27030
27031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27032   void * jresult ;
27033   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27034   Dali::TouchPointContainer *result = 0 ;
27035
27036   arg1 = (Dali::HoverEvent *)jarg1;
27037   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27038   jresult = (void *)result;
27039   return jresult;
27040 }
27041
27042
27043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27044   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27045   unsigned long arg2 ;
27046
27047   arg1 = (Dali::HoverEvent *)jarg1;
27048   arg2 = (unsigned long)jarg2;
27049   if (arg1) (arg1)->time = arg2;
27050 }
27051
27052
27053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27054   unsigned long jresult ;
27055   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27056   unsigned long result;
27057
27058   arg1 = (Dali::HoverEvent *)jarg1;
27059   result = (unsigned long) ((arg1)->time);
27060   jresult = (unsigned long)result;
27061   return jresult;
27062 }
27063
27064
27065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27066   unsigned int jresult ;
27067   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27068   unsigned int result;
27069
27070   arg1 = (Dali::HoverEvent *)jarg1;
27071   {
27072     try {
27073       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27074     } catch (std::out_of_range& e) {
27075       {
27076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27077       };
27078     } catch (std::exception& e) {
27079       {
27080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27081       };
27082     } catch (...) {
27083       {
27084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27085       };
27086     }
27087   }
27088   jresult = result;
27089   return jresult;
27090 }
27091
27092
27093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27094   void * jresult ;
27095   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27096   unsigned int arg2 ;
27097   Dali::TouchPoint *result = 0 ;
27098
27099   arg1 = (Dali::HoverEvent *)jarg1;
27100   arg2 = (unsigned int)jarg2;
27101   {
27102     try {
27103       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27104     } catch (std::out_of_range& e) {
27105       {
27106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27107       };
27108     } catch (std::exception& e) {
27109       {
27110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27111       };
27112     } catch (...) {
27113       {
27114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27115       };
27116     }
27117   }
27118   jresult = (void *)result;
27119   return jresult;
27120 }
27121
27122
27123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27124   void * jresult ;
27125   Dali::KeyEvent *result = 0 ;
27126
27127   {
27128     try {
27129       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27130     } catch (std::out_of_range& e) {
27131       {
27132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27133       };
27134     } catch (std::exception& e) {
27135       {
27136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27137       };
27138     } catch (...) {
27139       {
27140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27141       };
27142     }
27143   }
27144   jresult = (void *)result;
27145   return jresult;
27146 }
27147
27148
27149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27150   void * jresult ;
27151   std::string *arg1 = 0 ;
27152   std::string *arg2 = 0 ;
27153   int arg3 ;
27154   int arg4 ;
27155   unsigned long arg5 ;
27156   Dali::KeyEvent::State *arg6 = 0 ;
27157   Dali::KeyEvent::State temp6 ;
27158   Dali::KeyEvent *result = 0 ;
27159
27160   if (!jarg1) {
27161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27162     return 0;
27163   }
27164   std::string arg1_str(jarg1);
27165   arg1 = &arg1_str;
27166   if (!jarg2) {
27167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27168     return 0;
27169   }
27170   std::string arg2_str(jarg2);
27171   arg2 = &arg2_str;
27172   arg3 = (int)jarg3;
27173   arg4 = (int)jarg4;
27174   arg5 = (unsigned long)jarg5;
27175   temp6 = (Dali::KeyEvent::State)jarg6;
27176   arg6 = &temp6;
27177   {
27178     try {
27179       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27180     } catch (std::out_of_range& e) {
27181       {
27182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27183       };
27184     } catch (std::exception& e) {
27185       {
27186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27187       };
27188     } catch (...) {
27189       {
27190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27191       };
27192     }
27193   }
27194   jresult = (void *)result;
27195
27196   //argout typemap for const std::string&
27197
27198
27199   //argout typemap for const std::string&
27200
27201   return jresult;
27202 }
27203
27204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27205   void * jresult ;
27206   Dali::KeyEvent *arg1 = 0 ;
27207   Dali::KeyEvent *result = 0 ;
27208
27209   arg1 = (Dali::KeyEvent *)jarg1;
27210   if (!arg1) {
27211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27212     return 0;
27213   }
27214   {
27215     try {
27216       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27217     } catch (std::out_of_range& e) {
27218       {
27219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27220       };
27221     } catch (std::exception& e) {
27222       {
27223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27224       };
27225     } catch (...) {
27226       {
27227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27228       };
27229     }
27230   }
27231   jresult = (void *)result;
27232   return jresult;
27233 }
27234
27235
27236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27237   void * jresult ;
27238   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27239   Dali::KeyEvent *arg2 = 0 ;
27240   Dali::KeyEvent *result = 0 ;
27241
27242   arg1 = (Dali::KeyEvent *)jarg1;
27243   arg2 = (Dali::KeyEvent *)jarg2;
27244   if (!arg2) {
27245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27246     return 0;
27247   }
27248   {
27249     try {
27250       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27251     } catch (std::out_of_range& e) {
27252       {
27253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27254       };
27255     } catch (std::exception& e) {
27256       {
27257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27258       };
27259     } catch (...) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27262       };
27263     }
27264   }
27265   jresult = (void *)result;
27266   return jresult;
27267 }
27268
27269
27270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27271   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27272
27273   arg1 = (Dali::KeyEvent *)jarg1;
27274   {
27275     try {
27276       delete arg1;
27277     } catch (std::out_of_range& e) {
27278       {
27279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27280       };
27281     } catch (std::exception& e) {
27282       {
27283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27284       };
27285     } catch (...) {
27286       {
27287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27288       };
27289     }
27290   }
27291 }
27292
27293
27294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27295   unsigned int jresult ;
27296   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27297   bool result;
27298
27299   arg1 = (Dali::KeyEvent *)jarg1;
27300   {
27301     try {
27302       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27303     } catch (std::out_of_range& e) {
27304       {
27305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27306       };
27307     } catch (std::exception& e) {
27308       {
27309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27310       };
27311     } catch (...) {
27312       {
27313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27314       };
27315     }
27316   }
27317   jresult = result;
27318   return jresult;
27319 }
27320
27321
27322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27323   unsigned int jresult ;
27324   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27325   bool result;
27326
27327   arg1 = (Dali::KeyEvent *)jarg1;
27328   {
27329     try {
27330       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27331     } catch (std::out_of_range& e) {
27332       {
27333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27334       };
27335     } catch (std::exception& e) {
27336       {
27337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27338       };
27339     } catch (...) {
27340       {
27341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27342       };
27343     }
27344   }
27345   jresult = result;
27346   return jresult;
27347 }
27348
27349
27350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27351   unsigned int jresult ;
27352   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27353   bool result;
27354
27355   arg1 = (Dali::KeyEvent *)jarg1;
27356   {
27357     try {
27358       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27359     } catch (std::out_of_range& e) {
27360       {
27361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27362       };
27363     } catch (std::exception& e) {
27364       {
27365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27366       };
27367     } catch (...) {
27368       {
27369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27370       };
27371     }
27372   }
27373   jresult = result;
27374   return jresult;
27375 }
27376
27377
27378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27379   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27380   std::string *arg2 = 0 ;
27381
27382   arg1 = (Dali::KeyEvent *)jarg1;
27383   if (!jarg2) {
27384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27385     return ;
27386   }
27387   std::string arg2_str(jarg2);
27388   arg2 = &arg2_str;
27389   if (arg1) (arg1)->keyPressedName = *arg2;
27390
27391   //argout typemap for const std::string&
27392
27393 }
27394
27395
27396 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27397   char * jresult ;
27398   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27399   std::string *result = 0 ;
27400
27401   arg1 = (Dali::KeyEvent *)jarg1;
27402   result = (std::string *) & ((arg1)->keyPressedName);
27403   jresult = SWIG_csharp_string_callback(result->c_str());
27404   return jresult;
27405 }
27406
27407
27408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27409   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27410   std::string *arg2 = 0 ;
27411
27412   arg1 = (Dali::KeyEvent *)jarg1;
27413   if (!jarg2) {
27414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27415     return ;
27416   }
27417   std::string arg2_str(jarg2);
27418   arg2 = &arg2_str;
27419   if (arg1) (arg1)->keyPressed = *arg2;
27420
27421   //argout typemap for const std::string&
27422
27423 }
27424
27425
27426 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27427   char * jresult ;
27428   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27429   std::string *result = 0 ;
27430
27431   arg1 = (Dali::KeyEvent *)jarg1;
27432   result = (std::string *) & ((arg1)->keyPressed);
27433   jresult = SWIG_csharp_string_callback(result->c_str());
27434   return jresult;
27435 }
27436
27437
27438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27439   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27440   int arg2 ;
27441
27442   arg1 = (Dali::KeyEvent *)jarg1;
27443   arg2 = (int)jarg2;
27444   if (arg1) (arg1)->keyCode = arg2;
27445 }
27446
27447
27448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27449   int jresult ;
27450   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27451   int result;
27452
27453   arg1 = (Dali::KeyEvent *)jarg1;
27454   result = (int) ((arg1)->keyCode);
27455   jresult = result;
27456   return jresult;
27457 }
27458
27459
27460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27461   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27462   int arg2 ;
27463
27464   arg1 = (Dali::KeyEvent *)jarg1;
27465   arg2 = (int)jarg2;
27466   if (arg1) (arg1)->keyModifier = arg2;
27467 }
27468
27469
27470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27471   int jresult ;
27472   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27473   int result;
27474
27475   arg1 = (Dali::KeyEvent *)jarg1;
27476   result = (int) ((arg1)->keyModifier);
27477   jresult = result;
27478   return jresult;
27479 }
27480
27481
27482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27483   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27484   unsigned long arg2 ;
27485
27486   arg1 = (Dali::KeyEvent *)jarg1;
27487   arg2 = (unsigned long)jarg2;
27488   if (arg1) (arg1)->time = arg2;
27489 }
27490
27491
27492 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27493   unsigned long jresult ;
27494   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27495   unsigned long result;
27496
27497   arg1 = (Dali::KeyEvent *)jarg1;
27498   result = (unsigned long) ((arg1)->time);
27499   jresult = (unsigned long)result;
27500   return jresult;
27501 }
27502
27503
27504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27505   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27506   Dali::KeyEvent::State arg2 ;
27507
27508   arg1 = (Dali::KeyEvent *)jarg1;
27509   arg2 = (Dali::KeyEvent::State)jarg2;
27510   if (arg1) (arg1)->state = arg2;
27511 }
27512
27513
27514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27515   int jresult ;
27516   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27517   Dali::KeyEvent::State result;
27518
27519   arg1 = (Dali::KeyEvent *)jarg1;
27520   result = (Dali::KeyEvent::State) ((arg1)->state);
27521   jresult = (int)result;
27522   return jresult;
27523 }
27524
27525
27526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27527   void * jresult ;
27528   Dali::LongPressGestureDetector *result = 0 ;
27529
27530   {
27531     try {
27532       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27533     } catch (std::out_of_range& e) {
27534       {
27535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27536       };
27537     } catch (std::exception& e) {
27538       {
27539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27540       };
27541     } catch (...) {
27542       {
27543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27544       };
27545     }
27546   }
27547   jresult = (void *)result;
27548   return jresult;
27549 }
27550
27551
27552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27553   void * jresult ;
27554   Dali::LongPressGestureDetector result;
27555
27556   {
27557     try {
27558       result = Dali::LongPressGestureDetector::New();
27559     } catch (std::out_of_range& e) {
27560       {
27561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27562       };
27563     } catch (std::exception& e) {
27564       {
27565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27566       };
27567     } catch (...) {
27568       {
27569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27570       };
27571     }
27572   }
27573   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27574   return jresult;
27575 }
27576
27577
27578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27579   void * jresult ;
27580   unsigned int arg1 ;
27581   Dali::LongPressGestureDetector result;
27582
27583   arg1 = (unsigned int)jarg1;
27584   {
27585     try {
27586       result = Dali::LongPressGestureDetector::New(arg1);
27587     } catch (std::out_of_range& e) {
27588       {
27589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27590       };
27591     } catch (std::exception& e) {
27592       {
27593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27594       };
27595     } catch (...) {
27596       {
27597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27598       };
27599     }
27600   }
27601   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27602   return jresult;
27603 }
27604
27605
27606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27607   void * jresult ;
27608   unsigned int arg1 ;
27609   unsigned int arg2 ;
27610   Dali::LongPressGestureDetector result;
27611
27612   arg1 = (unsigned int)jarg1;
27613   arg2 = (unsigned int)jarg2;
27614   {
27615     try {
27616       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27617     } catch (std::out_of_range& e) {
27618       {
27619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27620       };
27621     } catch (std::exception& e) {
27622       {
27623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27624       };
27625     } catch (...) {
27626       {
27627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27628       };
27629     }
27630   }
27631   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27632   return jresult;
27633 }
27634
27635
27636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27637   void * jresult ;
27638   Dali::BaseHandle arg1 ;
27639   Dali::BaseHandle *argp1 ;
27640   Dali::LongPressGestureDetector result;
27641
27642   argp1 = (Dali::BaseHandle *)jarg1;
27643   if (!argp1) {
27644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27645     return 0;
27646   }
27647   arg1 = *argp1;
27648   {
27649     try {
27650       result = Dali::LongPressGestureDetector::DownCast(arg1);
27651     } catch (std::out_of_range& e) {
27652       {
27653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27654       };
27655     } catch (std::exception& e) {
27656       {
27657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27658       };
27659     } catch (...) {
27660       {
27661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27662       };
27663     }
27664   }
27665   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27666   return jresult;
27667 }
27668
27669
27670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27671   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27672
27673   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27674   {
27675     try {
27676       delete arg1;
27677     } catch (std::out_of_range& e) {
27678       {
27679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27680       };
27681     } catch (std::exception& e) {
27682       {
27683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27684       };
27685     } catch (...) {
27686       {
27687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27688       };
27689     }
27690   }
27691 }
27692
27693
27694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27695   void * jresult ;
27696   Dali::LongPressGestureDetector *arg1 = 0 ;
27697   Dali::LongPressGestureDetector *result = 0 ;
27698
27699   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27700   if (!arg1) {
27701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27702     return 0;
27703   }
27704   {
27705     try {
27706       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27707     } catch (std::out_of_range& e) {
27708       {
27709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27710       };
27711     } catch (std::exception& e) {
27712       {
27713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27714       };
27715     } catch (...) {
27716       {
27717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27718       };
27719     }
27720   }
27721   jresult = (void *)result;
27722   return jresult;
27723 }
27724
27725
27726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27727   void * jresult ;
27728   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27729   Dali::LongPressGestureDetector *arg2 = 0 ;
27730   Dali::LongPressGestureDetector *result = 0 ;
27731
27732   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27733   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27734   if (!arg2) {
27735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27736     return 0;
27737   }
27738   {
27739     try {
27740       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27741     } catch (std::out_of_range& e) {
27742       {
27743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27744       };
27745     } catch (std::exception& e) {
27746       {
27747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27748       };
27749     } catch (...) {
27750       {
27751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27752       };
27753     }
27754   }
27755   jresult = (void *)result;
27756   return jresult;
27757 }
27758
27759
27760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27761   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27762   unsigned int arg2 ;
27763
27764   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27765   arg2 = (unsigned int)jarg2;
27766   {
27767     try {
27768       (arg1)->SetTouchesRequired(arg2);
27769     } catch (std::out_of_range& e) {
27770       {
27771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27772       };
27773     } catch (std::exception& e) {
27774       {
27775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27776       };
27777     } catch (...) {
27778       {
27779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27780       };
27781     }
27782   }
27783 }
27784
27785
27786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27787   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27788   unsigned int arg2 ;
27789   unsigned int arg3 ;
27790
27791   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27792   arg2 = (unsigned int)jarg2;
27793   arg3 = (unsigned int)jarg3;
27794   {
27795     try {
27796       (arg1)->SetTouchesRequired(arg2,arg3);
27797     } catch (std::out_of_range& e) {
27798       {
27799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27800       };
27801     } catch (std::exception& e) {
27802       {
27803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27804       };
27805     } catch (...) {
27806       {
27807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27808       };
27809     }
27810   }
27811 }
27812
27813
27814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27815   unsigned int jresult ;
27816   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27817   unsigned int result;
27818
27819   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27820   {
27821     try {
27822       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27823     } catch (std::out_of_range& e) {
27824       {
27825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27826       };
27827     } catch (std::exception& e) {
27828       {
27829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27830       };
27831     } catch (...) {
27832       {
27833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27834       };
27835     }
27836   }
27837   jresult = result;
27838   return jresult;
27839 }
27840
27841
27842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27843   unsigned int jresult ;
27844   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27845   unsigned int result;
27846
27847   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27848   {
27849     try {
27850       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27851     } catch (std::out_of_range& e) {
27852       {
27853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27854       };
27855     } catch (std::exception& e) {
27856       {
27857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27858       };
27859     } catch (...) {
27860       {
27861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27862       };
27863     }
27864   }
27865   jresult = result;
27866   return jresult;
27867 }
27868
27869
27870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27871   void * jresult ;
27872   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27873   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27874
27875   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27876   {
27877     try {
27878       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27879     } catch (std::out_of_range& e) {
27880       {
27881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27882       };
27883     } catch (std::exception& e) {
27884       {
27885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27886       };
27887     } catch (...) {
27888       {
27889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27890       };
27891     }
27892   }
27893   jresult = (void *)result;
27894   return jresult;
27895 }
27896
27897
27898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27899   void * jresult ;
27900   Dali::Gesture::State arg1 ;
27901   Dali::LongPressGesture *result = 0 ;
27902
27903   arg1 = (Dali::Gesture::State)jarg1;
27904   {
27905     try {
27906       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27907     } catch (std::out_of_range& e) {
27908       {
27909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27910       };
27911     } catch (std::exception& e) {
27912       {
27913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27914       };
27915     } catch (...) {
27916       {
27917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27918       };
27919     }
27920   }
27921   jresult = (void *)result;
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27927   void * jresult ;
27928   Dali::LongPressGesture *arg1 = 0 ;
27929   Dali::LongPressGesture *result = 0 ;
27930
27931   arg1 = (Dali::LongPressGesture *)jarg1;
27932   if (!arg1) {
27933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27934     return 0;
27935   }
27936   {
27937     try {
27938       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27939     } catch (std::out_of_range& e) {
27940       {
27941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27942       };
27943     } catch (std::exception& e) {
27944       {
27945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27946       };
27947     } catch (...) {
27948       {
27949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27950       };
27951     }
27952   }
27953   jresult = (void *)result;
27954   return jresult;
27955 }
27956
27957
27958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27959   void * jresult ;
27960   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27961   Dali::LongPressGesture *arg2 = 0 ;
27962   Dali::LongPressGesture *result = 0 ;
27963
27964   arg1 = (Dali::LongPressGesture *)jarg1;
27965   arg2 = (Dali::LongPressGesture *)jarg2;
27966   if (!arg2) {
27967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27968     return 0;
27969   }
27970   {
27971     try {
27972       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27973     } catch (std::out_of_range& e) {
27974       {
27975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27976       };
27977     } catch (std::exception& e) {
27978       {
27979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27980       };
27981     } catch (...) {
27982       {
27983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27984       };
27985     }
27986   }
27987   jresult = (void *)result;
27988   return jresult;
27989 }
27990
27991
27992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
27993   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27994
27995   arg1 = (Dali::LongPressGesture *)jarg1;
27996   {
27997     try {
27998       delete arg1;
27999     } catch (std::out_of_range& e) {
28000       {
28001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28002       };
28003     } catch (std::exception& e) {
28004       {
28005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28006       };
28007     } catch (...) {
28008       {
28009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28010       };
28011     }
28012   }
28013 }
28014
28015
28016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28017   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28018   unsigned int arg2 ;
28019
28020   arg1 = (Dali::LongPressGesture *)jarg1;
28021   arg2 = (unsigned int)jarg2;
28022   if (arg1) (arg1)->numberOfTouches = arg2;
28023 }
28024
28025
28026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28027   unsigned int jresult ;
28028   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28029   unsigned int result;
28030
28031   arg1 = (Dali::LongPressGesture *)jarg1;
28032   result = (unsigned int) ((arg1)->numberOfTouches);
28033   jresult = result;
28034   return jresult;
28035 }
28036
28037
28038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28039   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28040   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28041
28042   arg1 = (Dali::LongPressGesture *)jarg1;
28043   arg2 = (Dali::Vector2 *)jarg2;
28044   if (arg1) (arg1)->screenPoint = *arg2;
28045 }
28046
28047
28048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28049   void * jresult ;
28050   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28051   Dali::Vector2 *result = 0 ;
28052
28053   arg1 = (Dali::LongPressGesture *)jarg1;
28054   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28055   jresult = (void *)result;
28056   return jresult;
28057 }
28058
28059
28060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28061   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28062   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28063
28064   arg1 = (Dali::LongPressGesture *)jarg1;
28065   arg2 = (Dali::Vector2 *)jarg2;
28066   if (arg1) (arg1)->localPoint = *arg2;
28067 }
28068
28069
28070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28071   void * jresult ;
28072   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28073   Dali::Vector2 *result = 0 ;
28074
28075   arg1 = (Dali::LongPressGesture *)jarg1;
28076   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28077   jresult = (void *)result;
28078   return jresult;
28079 }
28080
28081
28082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28083   void * jresult ;
28084   Dali::WheelEvent *result = 0 ;
28085
28086   {
28087     try {
28088       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28089     } catch (std::out_of_range& e) {
28090       {
28091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28092       };
28093     } catch (std::exception& e) {
28094       {
28095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28096       };
28097     } catch (...) {
28098       {
28099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28100       };
28101     }
28102   }
28103   jresult = (void *)result;
28104   return jresult;
28105 }
28106
28107
28108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28109   void * jresult ;
28110   Dali::WheelEvent::Type arg1 ;
28111   int arg2 ;
28112   unsigned int arg3 ;
28113   Dali::Vector2 arg4 ;
28114   int arg5 ;
28115   unsigned int arg6 ;
28116   Dali::Vector2 *argp4 ;
28117   Dali::WheelEvent *result = 0 ;
28118
28119   arg1 = (Dali::WheelEvent::Type)jarg1;
28120   arg2 = (int)jarg2;
28121   arg3 = (unsigned int)jarg3;
28122   argp4 = (Dali::Vector2 *)jarg4;
28123   if (!argp4) {
28124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28125     return 0;
28126   }
28127   arg4 = *argp4;
28128   arg5 = (int)jarg5;
28129   arg6 = (unsigned int)jarg6;
28130   {
28131     try {
28132       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28133     } catch (std::out_of_range& e) {
28134       {
28135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28136       };
28137     } catch (std::exception& e) {
28138       {
28139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28140       };
28141     } catch (...) {
28142       {
28143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28144       };
28145     }
28146   }
28147   jresult = (void *)result;
28148   return jresult;
28149 }
28150
28151
28152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28153   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28154
28155   arg1 = (Dali::WheelEvent *)jarg1;
28156   {
28157     try {
28158       delete arg1;
28159     } catch (std::out_of_range& e) {
28160       {
28161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28162       };
28163     } catch (std::exception& e) {
28164       {
28165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28166       };
28167     } catch (...) {
28168       {
28169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28170       };
28171     }
28172   }
28173 }
28174
28175
28176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28177   unsigned int jresult ;
28178   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28179   bool result;
28180
28181   arg1 = (Dali::WheelEvent *)jarg1;
28182   {
28183     try {
28184       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28185     } catch (std::out_of_range& e) {
28186       {
28187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28188       };
28189     } catch (std::exception& e) {
28190       {
28191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28192       };
28193     } catch (...) {
28194       {
28195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28196       };
28197     }
28198   }
28199   jresult = result;
28200   return jresult;
28201 }
28202
28203
28204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28205   unsigned int jresult ;
28206   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28207   bool result;
28208
28209   arg1 = (Dali::WheelEvent *)jarg1;
28210   {
28211     try {
28212       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28213     } catch (std::out_of_range& e) {
28214       {
28215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28216       };
28217     } catch (std::exception& e) {
28218       {
28219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28220       };
28221     } catch (...) {
28222       {
28223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28224       };
28225     }
28226   }
28227   jresult = result;
28228   return jresult;
28229 }
28230
28231
28232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28233   unsigned int jresult ;
28234   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28235   bool result;
28236
28237   arg1 = (Dali::WheelEvent *)jarg1;
28238   {
28239     try {
28240       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28241     } catch (std::out_of_range& e) {
28242       {
28243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28244       };
28245     } catch (std::exception& e) {
28246       {
28247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28248       };
28249     } catch (...) {
28250       {
28251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28252       };
28253     }
28254   }
28255   jresult = result;
28256   return jresult;
28257 }
28258
28259
28260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28261   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28262   Dali::WheelEvent::Type arg2 ;
28263
28264   arg1 = (Dali::WheelEvent *)jarg1;
28265   arg2 = (Dali::WheelEvent::Type)jarg2;
28266   if (arg1) (arg1)->type = arg2;
28267 }
28268
28269
28270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28271   int jresult ;
28272   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28273   Dali::WheelEvent::Type result;
28274
28275   arg1 = (Dali::WheelEvent *)jarg1;
28276   result = (Dali::WheelEvent::Type) ((arg1)->type);
28277   jresult = (int)result;
28278   return jresult;
28279 }
28280
28281
28282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28283   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28284   int arg2 ;
28285
28286   arg1 = (Dali::WheelEvent *)jarg1;
28287   arg2 = (int)jarg2;
28288   if (arg1) (arg1)->direction = arg2;
28289 }
28290
28291
28292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28293   int jresult ;
28294   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28295   int result;
28296
28297   arg1 = (Dali::WheelEvent *)jarg1;
28298   result = (int) ((arg1)->direction);
28299   jresult = result;
28300   return jresult;
28301 }
28302
28303
28304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28305   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28306   unsigned int arg2 ;
28307
28308   arg1 = (Dali::WheelEvent *)jarg1;
28309   arg2 = (unsigned int)jarg2;
28310   if (arg1) (arg1)->modifiers = arg2;
28311 }
28312
28313
28314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28315   unsigned int jresult ;
28316   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28317   unsigned int result;
28318
28319   arg1 = (Dali::WheelEvent *)jarg1;
28320   result = (unsigned int) ((arg1)->modifiers);
28321   jresult = result;
28322   return jresult;
28323 }
28324
28325
28326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28327   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28328   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28329
28330   arg1 = (Dali::WheelEvent *)jarg1;
28331   arg2 = (Dali::Vector2 *)jarg2;
28332   if (arg1) (arg1)->point = *arg2;
28333 }
28334
28335
28336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28337   void * jresult ;
28338   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28339   Dali::Vector2 *result = 0 ;
28340
28341   arg1 = (Dali::WheelEvent *)jarg1;
28342   result = (Dali::Vector2 *)& ((arg1)->point);
28343   jresult = (void *)result;
28344   return jresult;
28345 }
28346
28347
28348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28349   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28350   int arg2 ;
28351
28352   arg1 = (Dali::WheelEvent *)jarg1;
28353   arg2 = (int)jarg2;
28354   if (arg1) (arg1)->z = arg2;
28355 }
28356
28357
28358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28359   int jresult ;
28360   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28361   int result;
28362
28363   arg1 = (Dali::WheelEvent *)jarg1;
28364   result = (int) ((arg1)->z);
28365   jresult = result;
28366   return jresult;
28367 }
28368
28369
28370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28371   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28372   unsigned int arg2 ;
28373
28374   arg1 = (Dali::WheelEvent *)jarg1;
28375   arg2 = (unsigned int)jarg2;
28376   if (arg1) (arg1)->timeStamp = arg2;
28377 }
28378
28379
28380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28381   unsigned int jresult ;
28382   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28383   unsigned int result;
28384
28385   arg1 = (Dali::WheelEvent *)jarg1;
28386   result = (unsigned int) ((arg1)->timeStamp);
28387   jresult = result;
28388   return jresult;
28389 }
28390
28391 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28392   char * jresult ;
28393   Dali::KeyEvent *arg1 = 0 ;
28394   std::string result;
28395
28396   arg1 = (Dali::KeyEvent *)jarg1;
28397   if (!arg1) {
28398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28399     return 0;
28400   }
28401   {
28402     try {
28403       result = arg1->GetDeviceName();
28404     } catch (std::out_of_range& e) {
28405       {
28406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28407       };
28408     } catch (std::exception& e) {
28409       {
28410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28411       };
28412     } catch (...) {
28413       {
28414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28415       };
28416     }
28417   }
28418   jresult = SWIG_csharp_string_callback((&result)->c_str());
28419   return jresult;
28420 }
28421
28422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28423   int jresult ;
28424   Dali::KeyEvent *arg1 = 0 ;
28425   Dali::Device::Class::Type result;
28426
28427   arg1 = (Dali::KeyEvent *)jarg1;
28428   if (!arg1) {
28429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28430     return 0;
28431   }
28432   {
28433     try {
28434       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
28435     } catch (std::out_of_range& e) {
28436       {
28437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28438       };
28439     } catch (std::exception& e) {
28440       {
28441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28442       };
28443     } catch (...) {
28444       {
28445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28446       };
28447     }
28448   }
28449   jresult = (int)result;
28450   return jresult;
28451 }
28452
28453
28454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28455   Dali::Actor arg1 ;
28456   Dali::Actor *argp1 ;
28457
28458   argp1 = (Dali::Actor *)jarg1;
28459   if (!argp1) {
28460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28461     return ;
28462   }
28463   arg1 = *argp1;
28464   {
28465     try {
28466       arg1.Raise();
28467     } catch (std::out_of_range& e) {
28468       {
28469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28470       };
28471     } catch (std::exception& e) {
28472       {
28473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28474       };
28475     } catch (...) {
28476       {
28477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28478       };
28479     }
28480   }
28481 }
28482
28483
28484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28485   Dali::Actor arg1 ;
28486   Dali::Actor *argp1 ;
28487
28488   argp1 = (Dali::Actor *)jarg1;
28489   if (!argp1) {
28490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28491     return ;
28492   }
28493   arg1 = *argp1;
28494   {
28495     try {
28496       arg1.Lower();
28497     } catch (std::out_of_range& e) {
28498       {
28499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28500       };
28501     } catch (std::exception& e) {
28502       {
28503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28504       };
28505     } catch (...) {
28506       {
28507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28508       };
28509     }
28510   }
28511 }
28512
28513
28514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28515   Dali::Actor arg1 ;
28516   Dali::Actor *argp1 ;
28517
28518   argp1 = (Dali::Actor *)jarg1;
28519   if (!argp1) {
28520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28521     return ;
28522   }
28523   arg1 = *argp1;
28524   {
28525     try {
28526       arg1.RaiseToTop();
28527     } catch (std::out_of_range& e) {
28528       {
28529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28530       };
28531     } catch (std::exception& e) {
28532       {
28533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28534       };
28535     } catch (...) {
28536       {
28537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28538       };
28539     }
28540   }
28541 }
28542
28543
28544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28545   Dali::Actor arg1 ;
28546   Dali::Actor *argp1 ;
28547
28548   argp1 = (Dali::Actor *)jarg1;
28549   if (!argp1) {
28550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28551     return ;
28552   }
28553   arg1 = *argp1;
28554   {
28555     try {
28556       arg1.LowerToBottom();
28557     } catch (std::out_of_range& e) {
28558       {
28559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28560       };
28561     } catch (std::exception& e) {
28562       {
28563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28564       };
28565     } catch (...) {
28566       {
28567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28568       };
28569     }
28570   }
28571 }
28572
28573
28574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28575   Dali::Actor arg1 ;
28576   Dali::Actor arg2 ;
28577   Dali::Actor *argp1 ;
28578   Dali::Actor *argp2 ;
28579
28580   argp1 = (Dali::Actor *)jarg1;
28581   if (!argp1) {
28582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28583     return ;
28584   }
28585   arg1 = *argp1;
28586   argp2 = (Dali::Actor *)jarg2;
28587   if (!argp2) {
28588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28589     return ;
28590   }
28591   arg2 = *argp2;
28592   {
28593     try {
28594       arg1.RaiseAbove(arg2);
28595     } catch (std::out_of_range& e) {
28596       {
28597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28598       };
28599     } catch (std::exception& e) {
28600       {
28601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28602       };
28603     } catch (...) {
28604       {
28605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28606       };
28607     }
28608   }
28609 }
28610
28611
28612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28613   Dali::Actor arg1 ;
28614   Dali::Actor arg2 ;
28615   Dali::Actor *argp1 ;
28616   Dali::Actor *argp2 ;
28617
28618   argp1 = (Dali::Actor *)jarg1;
28619   if (!argp1) {
28620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28621     return ;
28622   }
28623   arg1 = *argp1;
28624   argp2 = (Dali::Actor *)jarg2;
28625   if (!argp2) {
28626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28627     return ;
28628   }
28629   arg2 = *argp2;
28630   {
28631     try {
28632       arg1.LowerBelow(arg2);
28633     } catch (std::out_of_range& e) {
28634       {
28635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28636       };
28637     } catch (std::exception& e) {
28638       {
28639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28640       };
28641     } catch (...) {
28642       {
28643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28644       };
28645     }
28646   }
28647 }
28648
28649
28650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28651   void * jresult ;
28652   Dali::Actor arg1 ;
28653   Dali::Actor *argp1 ;
28654   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28655
28656   argp1 = (Dali::Actor *)jarg1;
28657   if (!argp1) {
28658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28659     return 0;
28660   }
28661   arg1 = *argp1;
28662   {
28663     try {
28664       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28665     } catch (std::out_of_range& e) {
28666       {
28667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28668       };
28669     } catch (std::exception& e) {
28670       {
28671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28672       };
28673     } catch (...) {
28674       {
28675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28676       };
28677     }
28678   }
28679   jresult = (void *)result;
28680   return jresult;
28681 }
28682
28683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28684   int jresult ;
28685   int result;
28686
28687   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28688   jresult = (int)result;
28689   return jresult;
28690 }
28691
28692
28693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28694   int jresult ;
28695   int result;
28696
28697   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28698   jresult = (int)result;
28699   return jresult;
28700 }
28701
28702
28703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28704   int jresult ;
28705   int result;
28706
28707   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28708   jresult = (int)result;
28709   return jresult;
28710 }
28711
28712
28713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28714   int jresult ;
28715   int result;
28716
28717   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28718   jresult = (int)result;
28719   return jresult;
28720 }
28721
28722
28723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28724   int jresult ;
28725   int result;
28726
28727   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28728   jresult = (int)result;
28729   return jresult;
28730 }
28731
28732
28733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28734   int jresult ;
28735   int result;
28736
28737   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28738   jresult = (int)result;
28739   return jresult;
28740 }
28741
28742
28743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28744   int jresult ;
28745   int result;
28746
28747   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28748   jresult = (int)result;
28749   return jresult;
28750 }
28751
28752
28753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28754   int jresult ;
28755   int result;
28756
28757   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28758   jresult = (int)result;
28759   return jresult;
28760 }
28761
28762
28763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28764   int jresult ;
28765   int result;
28766
28767   result = (int)Dali::Actor::Property::SIZE;
28768   jresult = (int)result;
28769   return jresult;
28770 }
28771
28772
28773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28774   int jresult ;
28775   int result;
28776
28777   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28778   jresult = (int)result;
28779   return jresult;
28780 }
28781
28782
28783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28784   int jresult ;
28785   int result;
28786
28787   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28788   jresult = (int)result;
28789   return jresult;
28790 }
28791
28792
28793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28794   int jresult ;
28795   int result;
28796
28797   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28798   jresult = (int)result;
28799   return jresult;
28800 }
28801
28802
28803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28804   int jresult ;
28805   int result;
28806
28807   result = (int)Dali::Actor::Property::POSITION;
28808   jresult = (int)result;
28809   return jresult;
28810 }
28811
28812
28813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28814   int jresult ;
28815   int result;
28816
28817   result = (int)Dali::Actor::Property::POSITION_X;
28818   jresult = (int)result;
28819   return jresult;
28820 }
28821
28822
28823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28824   int jresult ;
28825   int result;
28826
28827   result = (int)Dali::Actor::Property::POSITION_Y;
28828   jresult = (int)result;
28829   return jresult;
28830 }
28831
28832
28833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28834   int jresult ;
28835   int result;
28836
28837   result = (int)Dali::Actor::Property::POSITION_Z;
28838   jresult = (int)result;
28839   return jresult;
28840 }
28841
28842
28843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28844   int jresult ;
28845   int result;
28846
28847   result = (int)Dali::Actor::Property::WORLD_POSITION;
28848   jresult = (int)result;
28849   return jresult;
28850 }
28851
28852
28853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28854   int jresult ;
28855   int result;
28856
28857   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28858   jresult = (int)result;
28859   return jresult;
28860 }
28861
28862
28863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28864   int jresult ;
28865   int result;
28866
28867   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28868   jresult = (int)result;
28869   return jresult;
28870 }
28871
28872
28873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28874   int jresult ;
28875   int result;
28876
28877   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28878   jresult = (int)result;
28879   return jresult;
28880 }
28881
28882
28883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28884   int jresult ;
28885   int result;
28886
28887   result = (int)Dali::Actor::Property::ORIENTATION;
28888   jresult = (int)result;
28889   return jresult;
28890 }
28891
28892
28893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28894   int jresult ;
28895   int result;
28896
28897   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28898   jresult = (int)result;
28899   return jresult;
28900 }
28901
28902
28903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28904   int jresult ;
28905   int result;
28906
28907   result = (int)Dali::Actor::Property::SCALE;
28908   jresult = (int)result;
28909   return jresult;
28910 }
28911
28912
28913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28914   int jresult ;
28915   int result;
28916
28917   result = (int)Dali::Actor::Property::SCALE_X;
28918   jresult = (int)result;
28919   return jresult;
28920 }
28921
28922
28923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28924   int jresult ;
28925   int result;
28926
28927   result = (int)Dali::Actor::Property::SCALE_Y;
28928   jresult = (int)result;
28929   return jresult;
28930 }
28931
28932
28933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28934   int jresult ;
28935   int result;
28936
28937   result = (int)Dali::Actor::Property::SCALE_Z;
28938   jresult = (int)result;
28939   return jresult;
28940 }
28941
28942
28943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28944   int jresult ;
28945   int result;
28946
28947   result = (int)Dali::Actor::Property::WORLD_SCALE;
28948   jresult = (int)result;
28949   return jresult;
28950 }
28951
28952
28953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28954   int jresult ;
28955   int result;
28956
28957   result = (int)Dali::Actor::Property::VISIBLE;
28958   jresult = (int)result;
28959   return jresult;
28960 }
28961
28962
28963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28964   int jresult ;
28965   int result;
28966
28967   result = (int)Dali::Actor::Property::COLOR;
28968   jresult = (int)result;
28969   return jresult;
28970 }
28971
28972
28973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28974   int jresult ;
28975   int result;
28976
28977   result = (int)Dali::Actor::Property::COLOR_RED;
28978   jresult = (int)result;
28979   return jresult;
28980 }
28981
28982
28983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28984   int jresult ;
28985   int result;
28986
28987   result = (int)Dali::Actor::Property::COLOR_GREEN;
28988   jresult = (int)result;
28989   return jresult;
28990 }
28991
28992
28993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28994   int jresult ;
28995   int result;
28996
28997   result = (int)Dali::Actor::Property::COLOR_BLUE;
28998   jresult = (int)result;
28999   return jresult;
29000 }
29001
29002
29003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29004   int jresult ;
29005   int result;
29006
29007   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29008   jresult = (int)result;
29009   return jresult;
29010 }
29011
29012
29013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29014   int jresult ;
29015   int result;
29016
29017   result = (int)Dali::Actor::Property::WORLD_COLOR;
29018   jresult = (int)result;
29019   return jresult;
29020 }
29021
29022
29023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29024   int jresult ;
29025   int result;
29026
29027   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29028   jresult = (int)result;
29029   return jresult;
29030 }
29031
29032
29033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29034   int jresult ;
29035   int result;
29036
29037   result = (int)Dali::Actor::Property::NAME;
29038   jresult = (int)result;
29039   return jresult;
29040 }
29041
29042
29043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29044   int jresult ;
29045   int result;
29046
29047   result = (int)Dali::Actor::Property::SENSITIVE;
29048   jresult = (int)result;
29049   return jresult;
29050 }
29051
29052
29053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29054   int jresult ;
29055   int result;
29056
29057   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29058   jresult = (int)result;
29059   return jresult;
29060 }
29061
29062
29063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29064   int jresult ;
29065   int result;
29066
29067   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29068   jresult = (int)result;
29069   return jresult;
29070 }
29071
29072
29073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29074   int jresult ;
29075   int result;
29076
29077   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29078   jresult = (int)result;
29079   return jresult;
29080 }
29081
29082
29083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29084   int jresult ;
29085   int result;
29086
29087   result = (int)Dali::Actor::Property::COLOR_MODE;
29088   jresult = (int)result;
29089   return jresult;
29090 }
29091
29092
29093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29094   int jresult ;
29095   int result;
29096
29097   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29098   jresult = (int)result;
29099   return jresult;
29100 }
29101
29102
29103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29104   int jresult ;
29105   int result;
29106
29107   result = (int)Dali::Actor::Property::DRAW_MODE;
29108   jresult = (int)result;
29109   return jresult;
29110 }
29111
29112
29113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29114   int jresult ;
29115   int result;
29116
29117   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29118   jresult = (int)result;
29119   return jresult;
29120 }
29121
29122
29123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29124   int jresult ;
29125   int result;
29126
29127   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29128   jresult = (int)result;
29129   return jresult;
29130 }
29131
29132
29133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29134   int jresult ;
29135   int result;
29136
29137   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29138   jresult = (int)result;
29139   return jresult;
29140 }
29141
29142
29143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29144   int jresult ;
29145   int result;
29146
29147   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29148   jresult = (int)result;
29149   return jresult;
29150 }
29151
29152
29153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29154   int jresult ;
29155   int result;
29156
29157   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29158   jresult = (int)result;
29159   return jresult;
29160 }
29161
29162
29163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29164   int jresult ;
29165   int result;
29166
29167   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29168   jresult = (int)result;
29169   return jresult;
29170 }
29171
29172
29173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29174   int jresult ;
29175   int result;
29176
29177   result = (int)Dali::Actor::Property::PADDING;
29178   jresult = (int)result;
29179   return jresult;
29180 }
29181
29182
29183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29184   int jresult ;
29185   int result;
29186
29187   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29188   jresult = (int)result;
29189   return jresult;
29190 }
29191
29192
29193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29194   int jresult ;
29195   int result;
29196
29197   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29198   jresult = (int)result;
29199   return jresult;
29200 }
29201
29202
29203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29204   int jresult ;
29205   int result;
29206
29207   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29208   jresult = (int)result;
29209   return jresult;
29210 }
29211
29212
29213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29214   int jresult ;
29215   int result;
29216
29217   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29218   jresult = (int)result;
29219   return jresult;
29220 }
29221
29222
29223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29224   void * jresult ;
29225   Dali::Actor::Property *result = 0 ;
29226
29227   {
29228     try {
29229       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29230     } catch (std::out_of_range& e) {
29231       {
29232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29233       };
29234     } catch (std::exception& e) {
29235       {
29236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29237       };
29238     } catch (...) {
29239       {
29240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29241       };
29242     }
29243   }
29244   jresult = (void *)result;
29245   return jresult;
29246 }
29247
29248
29249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29250   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29251
29252   arg1 = (Dali::Actor::Property *)jarg1;
29253   {
29254     try {
29255       delete arg1;
29256     } catch (std::out_of_range& e) {
29257       {
29258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29259       };
29260     } catch (std::exception& e) {
29261       {
29262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29263       };
29264     } catch (...) {
29265       {
29266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29267       };
29268     }
29269   }
29270 }
29271
29272
29273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29274   void * jresult ;
29275   Dali::Actor *result = 0 ;
29276
29277   {
29278     try {
29279       result = (Dali::Actor *)new Dali::Actor();
29280     } catch (std::out_of_range& e) {
29281       {
29282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29283       };
29284     } catch (std::exception& e) {
29285       {
29286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29287       };
29288     } catch (...) {
29289       {
29290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29291       };
29292     }
29293   }
29294   jresult = (void *)result;
29295   return jresult;
29296 }
29297
29298
29299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29300   void * jresult ;
29301   Dali::Actor result;
29302
29303   {
29304     try {
29305       result = Dali::Actor::New();
29306     } catch (std::out_of_range& e) {
29307       {
29308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29309       };
29310     } catch (std::exception& e) {
29311       {
29312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29313       };
29314     } catch (...) {
29315       {
29316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29317       };
29318     }
29319   }
29320   jresult = new Dali::Actor((const Dali::Actor &)result);
29321   return jresult;
29322 }
29323
29324
29325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29326   void * jresult ;
29327   Dali::BaseHandle arg1 ;
29328   Dali::BaseHandle *argp1 ;
29329   Dali::Actor result;
29330
29331   argp1 = (Dali::BaseHandle *)jarg1;
29332   if (!argp1) {
29333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29334     return 0;
29335   }
29336   arg1 = *argp1;
29337   {
29338     try {
29339       result = Dali::Actor::DownCast(arg1);
29340     } catch (std::out_of_range& e) {
29341       {
29342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29343       };
29344     } catch (std::exception& e) {
29345       {
29346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29347       };
29348     } catch (...) {
29349       {
29350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29351       };
29352     }
29353   }
29354   jresult = new Dali::Actor((const Dali::Actor &)result);
29355   return jresult;
29356 }
29357
29358
29359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29361
29362   arg1 = (Dali::Actor *)jarg1;
29363   {
29364     try {
29365       delete arg1;
29366     } catch (std::out_of_range& e) {
29367       {
29368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29369       };
29370     } catch (std::exception& e) {
29371       {
29372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29373       };
29374     } catch (...) {
29375       {
29376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29377       };
29378     }
29379   }
29380 }
29381
29382
29383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29384   void * jresult ;
29385   Dali::Actor *arg1 = 0 ;
29386   Dali::Actor *result = 0 ;
29387
29388   arg1 = (Dali::Actor *)jarg1;
29389   if (!arg1) {
29390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29391     return 0;
29392   }
29393   {
29394     try {
29395       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29396     } catch (std::out_of_range& e) {
29397       {
29398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29399       };
29400     } catch (std::exception& e) {
29401       {
29402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29403       };
29404     } catch (...) {
29405       {
29406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29407       };
29408     }
29409   }
29410   jresult = (void *)result;
29411   return jresult;
29412 }
29413
29414
29415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29416   void * jresult ;
29417   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29418   Dali::Actor *arg2 = 0 ;
29419   Dali::Actor *result = 0 ;
29420
29421   arg1 = (Dali::Actor *)jarg1;
29422   arg2 = (Dali::Actor *)jarg2;
29423   if (!arg2) {
29424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29425     return 0;
29426   }
29427   {
29428     try {
29429       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29430     } catch (std::out_of_range& e) {
29431       {
29432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29433       };
29434     } catch (std::exception& e) {
29435       {
29436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29437       };
29438     } catch (...) {
29439       {
29440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29441       };
29442     }
29443   }
29444   jresult = (void *)result;
29445   return jresult;
29446 }
29447
29448
29449 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29450   char * jresult ;
29451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29452   std::string *result = 0 ;
29453
29454   arg1 = (Dali::Actor *)jarg1;
29455   {
29456     try {
29457       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29458     } catch (std::out_of_range& e) {
29459       {
29460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29461       };
29462     } catch (std::exception& e) {
29463       {
29464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29465       };
29466     } catch (...) {
29467       {
29468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29469       };
29470     }
29471   }
29472   jresult = SWIG_csharp_string_callback(result->c_str());
29473   return jresult;
29474 }
29475
29476
29477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29478   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29479   std::string *arg2 = 0 ;
29480
29481   arg1 = (Dali::Actor *)jarg1;
29482   if (!jarg2) {
29483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29484     return ;
29485   }
29486   std::string arg2_str(jarg2);
29487   arg2 = &arg2_str;
29488   {
29489     try {
29490       (arg1)->SetName((std::string const &)*arg2);
29491     } catch (std::out_of_range& e) {
29492       {
29493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29494       };
29495     } catch (std::exception& e) {
29496       {
29497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29498       };
29499     } catch (...) {
29500       {
29501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29502       };
29503     }
29504   }
29505
29506   //argout typemap for const std::string&
29507
29508 }
29509
29510
29511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29512   unsigned int jresult ;
29513   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29514   unsigned int result;
29515
29516   arg1 = (Dali::Actor *)jarg1;
29517   {
29518     try {
29519       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29520     } catch (std::out_of_range& e) {
29521       {
29522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29523       };
29524     } catch (std::exception& e) {
29525       {
29526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29527       };
29528     } catch (...) {
29529       {
29530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29531       };
29532     }
29533   }
29534   jresult = result;
29535   return jresult;
29536 }
29537
29538
29539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29540   unsigned int jresult ;
29541   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29542   bool result;
29543
29544   arg1 = (Dali::Actor *)jarg1;
29545   {
29546     try {
29547       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29548     } catch (std::out_of_range& e) {
29549       {
29550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29551       };
29552     } catch (std::exception& e) {
29553       {
29554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29555       };
29556     } catch (...) {
29557       {
29558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29559       };
29560     }
29561   }
29562   jresult = result;
29563   return jresult;
29564 }
29565
29566
29567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29568   unsigned int jresult ;
29569   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29570   bool result;
29571
29572   arg1 = (Dali::Actor *)jarg1;
29573   {
29574     try {
29575       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29576     } catch (std::out_of_range& e) {
29577       {
29578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29579       };
29580     } catch (std::exception& e) {
29581       {
29582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29583       };
29584     } catch (...) {
29585       {
29586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29587       };
29588     }
29589   }
29590   jresult = result;
29591   return jresult;
29592 }
29593
29594
29595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29596   unsigned int jresult ;
29597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29598   bool result;
29599
29600   arg1 = (Dali::Actor *)jarg1;
29601   {
29602     try {
29603       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29604     } catch (std::out_of_range& e) {
29605       {
29606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29607       };
29608     } catch (std::exception& e) {
29609       {
29610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29611       };
29612     } catch (...) {
29613       {
29614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29615       };
29616     }
29617   }
29618   jresult = result;
29619   return jresult;
29620 }
29621
29622
29623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29624   void * jresult ;
29625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29626   Dali::Layer result;
29627
29628   arg1 = (Dali::Actor *)jarg1;
29629   {
29630     try {
29631       result = (arg1)->GetLayer();
29632     } catch (std::out_of_range& e) {
29633       {
29634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29635       };
29636     } catch (std::exception& e) {
29637       {
29638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29639       };
29640     } catch (...) {
29641       {
29642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29643       };
29644     }
29645   }
29646   jresult = new Dali::Layer((const Dali::Layer &)result);
29647   return jresult;
29648 }
29649
29650
29651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29652   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29653   Dali::Actor arg2 ;
29654   Dali::Actor *argp2 ;
29655
29656   arg1 = (Dali::Actor *)jarg1;
29657   argp2 = (Dali::Actor *)jarg2;
29658   if (!argp2) {
29659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29660     return ;
29661   }
29662   arg2 = *argp2;
29663   {
29664     try {
29665       (arg1)->Add(arg2);
29666     } catch (std::out_of_range& e) {
29667       {
29668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29669       };
29670     } catch (std::exception& e) {
29671       {
29672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29673       };
29674     } catch (...) {
29675       {
29676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29677       };
29678     }
29679   }
29680 }
29681
29682
29683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29685   Dali::Actor arg2 ;
29686   Dali::Actor *argp2 ;
29687
29688   arg1 = (Dali::Actor *)jarg1;
29689   argp2 = (Dali::Actor *)jarg2;
29690   if (!argp2) {
29691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29692     return ;
29693   }
29694   arg2 = *argp2;
29695   {
29696     try {
29697       (arg1)->Remove(arg2);
29698     } catch (std::out_of_range& e) {
29699       {
29700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29701       };
29702     } catch (std::exception& e) {
29703       {
29704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29705       };
29706     } catch (...) {
29707       {
29708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29709       };
29710     }
29711   }
29712 }
29713
29714
29715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29716   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29717
29718   arg1 = (Dali::Actor *)jarg1;
29719   {
29720     try {
29721       (arg1)->Unparent();
29722     } catch (std::out_of_range& e) {
29723       {
29724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29725       };
29726     } catch (std::exception& e) {
29727       {
29728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29729       };
29730     } catch (...) {
29731       {
29732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29733       };
29734     }
29735   }
29736 }
29737
29738
29739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29740   unsigned int jresult ;
29741   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29742   unsigned int result;
29743
29744   arg1 = (Dali::Actor *)jarg1;
29745   {
29746     try {
29747       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29748     } catch (std::out_of_range& e) {
29749       {
29750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29751       };
29752     } catch (std::exception& e) {
29753       {
29754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29755       };
29756     } catch (...) {
29757       {
29758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29759       };
29760     }
29761   }
29762   jresult = result;
29763   return jresult;
29764 }
29765
29766
29767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29768   void * jresult ;
29769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29770   unsigned int arg2 ;
29771   Dali::Actor result;
29772
29773   arg1 = (Dali::Actor *)jarg1;
29774   arg2 = (unsigned int)jarg2;
29775   {
29776     try {
29777       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29778     } catch (std::out_of_range& e) {
29779       {
29780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29781       };
29782     } catch (std::exception& e) {
29783       {
29784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29785       };
29786     } catch (...) {
29787       {
29788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29789       };
29790     }
29791   }
29792   jresult = new Dali::Actor((const Dali::Actor &)result);
29793   return jresult;
29794 }
29795
29796
29797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29798   void * jresult ;
29799   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29800   std::string *arg2 = 0 ;
29801   Dali::Actor result;
29802
29803   arg1 = (Dali::Actor *)jarg1;
29804   if (!jarg2) {
29805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29806     return 0;
29807   }
29808   std::string arg2_str(jarg2);
29809   arg2 = &arg2_str;
29810   {
29811     try {
29812       result = (arg1)->FindChildByName((std::string const &)*arg2);
29813     } catch (std::out_of_range& e) {
29814       {
29815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29816       };
29817     } catch (std::exception& e) {
29818       {
29819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29820       };
29821     } catch (...) {
29822       {
29823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29824       };
29825     }
29826   }
29827   jresult = new Dali::Actor((const Dali::Actor &)result);
29828
29829   //argout typemap for const std::string&
29830
29831   return jresult;
29832 }
29833
29834
29835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29836   void * jresult ;
29837   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29838   unsigned int arg2 ;
29839   Dali::Actor result;
29840
29841   arg1 = (Dali::Actor *)jarg1;
29842   arg2 = (unsigned int)jarg2;
29843   {
29844     try {
29845       result = (arg1)->FindChildById(arg2);
29846     } catch (std::out_of_range& e) {
29847       {
29848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29849       };
29850     } catch (std::exception& e) {
29851       {
29852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29853       };
29854     } catch (...) {
29855       {
29856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29857       };
29858     }
29859   }
29860   jresult = new Dali::Actor((const Dali::Actor &)result);
29861   return jresult;
29862 }
29863
29864
29865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29866   void * jresult ;
29867   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29868   Dali::Actor result;
29869
29870   arg1 = (Dali::Actor *)jarg1;
29871   {
29872     try {
29873       result = ((Dali::Actor const *)arg1)->GetParent();
29874     } catch (std::out_of_range& e) {
29875       {
29876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29877       };
29878     } catch (std::exception& e) {
29879       {
29880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29881       };
29882     } catch (...) {
29883       {
29884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29885       };
29886     }
29887   }
29888   jresult = new Dali::Actor((const Dali::Actor &)result);
29889   return jresult;
29890 }
29891
29892
29893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29895   Dali::Vector3 *arg2 = 0 ;
29896
29897   arg1 = (Dali::Actor *)jarg1;
29898   arg2 = (Dali::Vector3 *)jarg2;
29899   if (!arg2) {
29900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29901     return ;
29902   }
29903   {
29904     try {
29905       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29906     } catch (std::out_of_range& e) {
29907       {
29908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29909       };
29910     } catch (std::exception& e) {
29911       {
29912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29913       };
29914     } catch (...) {
29915       {
29916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29917       };
29918     }
29919   }
29920 }
29921
29922
29923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29924   void * jresult ;
29925   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29926   Dali::Vector3 result;
29927
29928   arg1 = (Dali::Actor *)jarg1;
29929   {
29930     try {
29931       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29932     } catch (std::out_of_range& e) {
29933       {
29934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29935       };
29936     } catch (std::exception& e) {
29937       {
29938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29939       };
29940     } catch (...) {
29941       {
29942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29943       };
29944     }
29945   }
29946   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29947   return jresult;
29948 }
29949
29950
29951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29953   Dali::Vector3 *arg2 = 0 ;
29954
29955   arg1 = (Dali::Actor *)jarg1;
29956   arg2 = (Dali::Vector3 *)jarg2;
29957   if (!arg2) {
29958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29959     return ;
29960   }
29961   {
29962     try {
29963       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29964     } catch (std::out_of_range& e) {
29965       {
29966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29967       };
29968     } catch (std::exception& e) {
29969       {
29970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29971       };
29972     } catch (...) {
29973       {
29974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29975       };
29976     }
29977   }
29978 }
29979
29980
29981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29982   void * jresult ;
29983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29984   Dali::Vector3 result;
29985
29986   arg1 = (Dali::Actor *)jarg1;
29987   {
29988     try {
29989       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29990     } catch (std::out_of_range& e) {
29991       {
29992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29993       };
29994     } catch (std::exception& e) {
29995       {
29996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29997       };
29998     } catch (...) {
29999       {
30000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30001       };
30002     }
30003   }
30004   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30005   return jresult;
30006 }
30007
30008
30009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30011   float arg2 ;
30012   float arg3 ;
30013
30014   arg1 = (Dali::Actor *)jarg1;
30015   arg2 = (float)jarg2;
30016   arg3 = (float)jarg3;
30017   {
30018     try {
30019       (arg1)->SetSize(arg2,arg3);
30020     } catch (std::out_of_range& e) {
30021       {
30022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30023       };
30024     } catch (std::exception& e) {
30025       {
30026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30027       };
30028     } catch (...) {
30029       {
30030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30031       };
30032     }
30033   }
30034 }
30035
30036
30037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30038   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30039   float arg2 ;
30040   float arg3 ;
30041   float arg4 ;
30042
30043   arg1 = (Dali::Actor *)jarg1;
30044   arg2 = (float)jarg2;
30045   arg3 = (float)jarg3;
30046   arg4 = (float)jarg4;
30047   {
30048     try {
30049       (arg1)->SetSize(arg2,arg3,arg4);
30050     } catch (std::out_of_range& e) {
30051       {
30052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30053       };
30054     } catch (std::exception& e) {
30055       {
30056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30057       };
30058     } catch (...) {
30059       {
30060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30061       };
30062     }
30063   }
30064 }
30065
30066
30067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30069   Dali::Vector2 *arg2 = 0 ;
30070
30071   arg1 = (Dali::Actor *)jarg1;
30072   arg2 = (Dali::Vector2 *)jarg2;
30073   if (!arg2) {
30074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30075     return ;
30076   }
30077   {
30078     try {
30079       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30080     } catch (std::out_of_range& e) {
30081       {
30082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30083       };
30084     } catch (std::exception& e) {
30085       {
30086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30087       };
30088     } catch (...) {
30089       {
30090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30091       };
30092     }
30093   }
30094 }
30095
30096
30097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30099   Dali::Vector3 *arg2 = 0 ;
30100
30101   arg1 = (Dali::Actor *)jarg1;
30102   arg2 = (Dali::Vector3 *)jarg2;
30103   if (!arg2) {
30104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30105     return ;
30106   }
30107   {
30108     try {
30109       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30110     } catch (std::out_of_range& e) {
30111       {
30112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30113       };
30114     } catch (std::exception& e) {
30115       {
30116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30117       };
30118     } catch (...) {
30119       {
30120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30121       };
30122     }
30123   }
30124 }
30125
30126
30127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30128   void * jresult ;
30129   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30130   Dali::Vector3 result;
30131
30132   arg1 = (Dali::Actor *)jarg1;
30133   {
30134     try {
30135       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30136     } catch (std::out_of_range& e) {
30137       {
30138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30139       };
30140     } catch (std::exception& e) {
30141       {
30142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30143       };
30144     } catch (...) {
30145       {
30146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30147       };
30148     }
30149   }
30150   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30151   return jresult;
30152 }
30153
30154
30155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30156   void * jresult ;
30157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30158   Dali::Vector3 result;
30159
30160   arg1 = (Dali::Actor *)jarg1;
30161   {
30162     try {
30163       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30164     } catch (std::out_of_range& e) {
30165       {
30166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30167       };
30168     } catch (std::exception& e) {
30169       {
30170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30171       };
30172     } catch (...) {
30173       {
30174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30175       };
30176     }
30177   }
30178   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30179   return jresult;
30180 }
30181
30182
30183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30184   void * jresult ;
30185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30186   Dali::Vector3 result;
30187
30188   arg1 = (Dali::Actor *)jarg1;
30189   {
30190     try {
30191       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30192     } catch (std::out_of_range& e) {
30193       {
30194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30195       };
30196     } catch (std::exception& e) {
30197       {
30198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30199       };
30200     } catch (...) {
30201       {
30202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30203       };
30204     }
30205   }
30206   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30207   return jresult;
30208 }
30209
30210
30211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30213   float arg2 ;
30214   float arg3 ;
30215
30216   arg1 = (Dali::Actor *)jarg1;
30217   arg2 = (float)jarg2;
30218   arg3 = (float)jarg3;
30219   {
30220     try {
30221       (arg1)->SetPosition(arg2,arg3);
30222     } catch (std::out_of_range& e) {
30223       {
30224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30225       };
30226     } catch (std::exception& e) {
30227       {
30228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30229       };
30230     } catch (...) {
30231       {
30232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30233       };
30234     }
30235   }
30236 }
30237
30238
30239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30241   float arg2 ;
30242   float arg3 ;
30243   float arg4 ;
30244
30245   arg1 = (Dali::Actor *)jarg1;
30246   arg2 = (float)jarg2;
30247   arg3 = (float)jarg3;
30248   arg4 = (float)jarg4;
30249   {
30250     try {
30251       (arg1)->SetPosition(arg2,arg3,arg4);
30252     } catch (std::out_of_range& e) {
30253       {
30254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30255       };
30256     } catch (std::exception& e) {
30257       {
30258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30259       };
30260     } catch (...) {
30261       {
30262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30263       };
30264     }
30265   }
30266 }
30267
30268
30269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30270   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30271   Dali::Vector3 *arg2 = 0 ;
30272
30273   arg1 = (Dali::Actor *)jarg1;
30274   arg2 = (Dali::Vector3 *)jarg2;
30275   if (!arg2) {
30276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30277     return ;
30278   }
30279   {
30280     try {
30281       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30282     } catch (std::out_of_range& e) {
30283       {
30284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30285       };
30286     } catch (std::exception& e) {
30287       {
30288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30289       };
30290     } catch (...) {
30291       {
30292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30293       };
30294     }
30295   }
30296 }
30297
30298
30299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30300   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30301   float arg2 ;
30302
30303   arg1 = (Dali::Actor *)jarg1;
30304   arg2 = (float)jarg2;
30305   {
30306     try {
30307       (arg1)->SetX(arg2);
30308     } catch (std::out_of_range& e) {
30309       {
30310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30311       };
30312     } catch (std::exception& e) {
30313       {
30314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30315       };
30316     } catch (...) {
30317       {
30318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30319       };
30320     }
30321   }
30322 }
30323
30324
30325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30327   float arg2 ;
30328
30329   arg1 = (Dali::Actor *)jarg1;
30330   arg2 = (float)jarg2;
30331   {
30332     try {
30333       (arg1)->SetY(arg2);
30334     } catch (std::out_of_range& e) {
30335       {
30336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30337       };
30338     } catch (std::exception& e) {
30339       {
30340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30341       };
30342     } catch (...) {
30343       {
30344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30345       };
30346     }
30347   }
30348 }
30349
30350
30351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30352   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30353   float arg2 ;
30354
30355   arg1 = (Dali::Actor *)jarg1;
30356   arg2 = (float)jarg2;
30357   {
30358     try {
30359       (arg1)->SetZ(arg2);
30360     } catch (std::out_of_range& e) {
30361       {
30362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30363       };
30364     } catch (std::exception& e) {
30365       {
30366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30367       };
30368     } catch (...) {
30369       {
30370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30371       };
30372     }
30373   }
30374 }
30375
30376
30377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30379   Dali::Vector3 *arg2 = 0 ;
30380
30381   arg1 = (Dali::Actor *)jarg1;
30382   arg2 = (Dali::Vector3 *)jarg2;
30383   if (!arg2) {
30384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30385     return ;
30386   }
30387   {
30388     try {
30389       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30390     } catch (std::out_of_range& e) {
30391       {
30392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30393       };
30394     } catch (std::exception& e) {
30395       {
30396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30397       };
30398     } catch (...) {
30399       {
30400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30401       };
30402     }
30403   }
30404 }
30405
30406
30407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30408   void * jresult ;
30409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30410   Dali::Vector3 result;
30411
30412   arg1 = (Dali::Actor *)jarg1;
30413   {
30414     try {
30415       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30416     } catch (std::out_of_range& e) {
30417       {
30418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30419       };
30420     } catch (std::exception& e) {
30421       {
30422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30423       };
30424     } catch (...) {
30425       {
30426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30427       };
30428     }
30429   }
30430   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30431   return jresult;
30432 }
30433
30434
30435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30436   void * jresult ;
30437   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30438   Dali::Vector3 result;
30439
30440   arg1 = (Dali::Actor *)jarg1;
30441   {
30442     try {
30443       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30444     } catch (std::out_of_range& e) {
30445       {
30446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30447       };
30448     } catch (std::exception& e) {
30449       {
30450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30451       };
30452     } catch (...) {
30453       {
30454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30455       };
30456     }
30457   }
30458   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30459   return jresult;
30460 }
30461
30462
30463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30465   bool arg2 ;
30466
30467   arg1 = (Dali::Actor *)jarg1;
30468   arg2 = jarg2 ? true : false;
30469   {
30470     try {
30471       (arg1)->SetInheritPosition(arg2);
30472     } catch (std::out_of_range& e) {
30473       {
30474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30475       };
30476     } catch (std::exception& e) {
30477       {
30478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30479       };
30480     } catch (...) {
30481       {
30482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30483       };
30484     }
30485   }
30486 }
30487
30488
30489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30490   int jresult ;
30491   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30492   Dali::PositionInheritanceMode result;
30493
30494   arg1 = (Dali::Actor *)jarg1;
30495   {
30496     try {
30497       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30498     } catch (std::out_of_range& e) {
30499       {
30500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30501       };
30502     } catch (std::exception& e) {
30503       {
30504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30505       };
30506     } catch (...) {
30507       {
30508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30509       };
30510     }
30511   }
30512   jresult = (int)result;
30513   return jresult;
30514 }
30515
30516
30517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30518   unsigned int jresult ;
30519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30520   bool result;
30521
30522   arg1 = (Dali::Actor *)jarg1;
30523   {
30524     try {
30525       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30526     } catch (std::out_of_range& e) {
30527       {
30528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30529       };
30530     } catch (std::exception& e) {
30531       {
30532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30533       };
30534     } catch (...) {
30535       {
30536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30537       };
30538     }
30539   }
30540   jresult = result;
30541   return jresult;
30542 }
30543
30544
30545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30546   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30547   Dali::Degree *arg2 = 0 ;
30548   Dali::Vector3 *arg3 = 0 ;
30549
30550   arg1 = (Dali::Actor *)jarg1;
30551   arg2 = (Dali::Degree *)jarg2;
30552   if (!arg2) {
30553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30554     return ;
30555   }
30556   arg3 = (Dali::Vector3 *)jarg3;
30557   if (!arg3) {
30558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30559     return ;
30560   }
30561   {
30562     try {
30563       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30564     } catch (std::out_of_range& e) {
30565       {
30566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30567       };
30568     } catch (std::exception& e) {
30569       {
30570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30571       };
30572     } catch (...) {
30573       {
30574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30575       };
30576     }
30577   }
30578 }
30579
30580
30581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30582   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30583   Dali::Radian *arg2 = 0 ;
30584   Dali::Vector3 *arg3 = 0 ;
30585
30586   arg1 = (Dali::Actor *)jarg1;
30587   arg2 = (Dali::Radian *)jarg2;
30588   if (!arg2) {
30589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30590     return ;
30591   }
30592   arg3 = (Dali::Vector3 *)jarg3;
30593   if (!arg3) {
30594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30595     return ;
30596   }
30597   {
30598     try {
30599       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30600     } catch (std::out_of_range& e) {
30601       {
30602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30603       };
30604     } catch (std::exception& e) {
30605       {
30606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30607       };
30608     } catch (...) {
30609       {
30610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30611       };
30612     }
30613   }
30614 }
30615
30616
30617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30619   Dali::Quaternion *arg2 = 0 ;
30620
30621   arg1 = (Dali::Actor *)jarg1;
30622   arg2 = (Dali::Quaternion *)jarg2;
30623   if (!arg2) {
30624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30625     return ;
30626   }
30627   {
30628     try {
30629       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30630     } catch (std::out_of_range& e) {
30631       {
30632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30633       };
30634     } catch (std::exception& e) {
30635       {
30636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30637       };
30638     } catch (...) {
30639       {
30640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30641       };
30642     }
30643   }
30644 }
30645
30646
30647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30649   Dali::Degree *arg2 = 0 ;
30650   Dali::Vector3 *arg3 = 0 ;
30651
30652   arg1 = (Dali::Actor *)jarg1;
30653   arg2 = (Dali::Degree *)jarg2;
30654   if (!arg2) {
30655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30656     return ;
30657   }
30658   arg3 = (Dali::Vector3 *)jarg3;
30659   if (!arg3) {
30660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30661     return ;
30662   }
30663   {
30664     try {
30665       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30666     } catch (std::out_of_range& e) {
30667       {
30668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30669       };
30670     } catch (std::exception& e) {
30671       {
30672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30673       };
30674     } catch (...) {
30675       {
30676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30677       };
30678     }
30679   }
30680 }
30681
30682
30683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30685   Dali::Radian *arg2 = 0 ;
30686   Dali::Vector3 *arg3 = 0 ;
30687
30688   arg1 = (Dali::Actor *)jarg1;
30689   arg2 = (Dali::Radian *)jarg2;
30690   if (!arg2) {
30691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30692     return ;
30693   }
30694   arg3 = (Dali::Vector3 *)jarg3;
30695   if (!arg3) {
30696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30697     return ;
30698   }
30699   {
30700     try {
30701       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30702     } catch (std::out_of_range& e) {
30703       {
30704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30705       };
30706     } catch (std::exception& e) {
30707       {
30708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30709       };
30710     } catch (...) {
30711       {
30712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30713       };
30714     }
30715   }
30716 }
30717
30718
30719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30721   Dali::Quaternion *arg2 = 0 ;
30722
30723   arg1 = (Dali::Actor *)jarg1;
30724   arg2 = (Dali::Quaternion *)jarg2;
30725   if (!arg2) {
30726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30727     return ;
30728   }
30729   {
30730     try {
30731       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30732     } catch (std::out_of_range& e) {
30733       {
30734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30735       };
30736     } catch (std::exception& e) {
30737       {
30738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30739       };
30740     } catch (...) {
30741       {
30742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30743       };
30744     }
30745   }
30746 }
30747
30748
30749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30750   void * jresult ;
30751   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30752   Dali::Quaternion result;
30753
30754   arg1 = (Dali::Actor *)jarg1;
30755   {
30756     try {
30757       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30758     } catch (std::out_of_range& e) {
30759       {
30760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30761       };
30762     } catch (std::exception& e) {
30763       {
30764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30765       };
30766     } catch (...) {
30767       {
30768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30769       };
30770     }
30771   }
30772   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30773   return jresult;
30774 }
30775
30776
30777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30779   bool arg2 ;
30780
30781   arg1 = (Dali::Actor *)jarg1;
30782   arg2 = jarg2 ? true : false;
30783   {
30784     try {
30785       (arg1)->SetInheritOrientation(arg2);
30786     } catch (std::out_of_range& e) {
30787       {
30788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30789       };
30790     } catch (std::exception& e) {
30791       {
30792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30793       };
30794     } catch (...) {
30795       {
30796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30797       };
30798     }
30799   }
30800 }
30801
30802
30803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30804   unsigned int jresult ;
30805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30806   bool result;
30807
30808   arg1 = (Dali::Actor *)jarg1;
30809   {
30810     try {
30811       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30812     } catch (std::out_of_range& e) {
30813       {
30814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30815       };
30816     } catch (std::exception& e) {
30817       {
30818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30819       };
30820     } catch (...) {
30821       {
30822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30823       };
30824     }
30825   }
30826   jresult = result;
30827   return jresult;
30828 }
30829
30830
30831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30832   void * jresult ;
30833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30834   Dali::Quaternion result;
30835
30836   arg1 = (Dali::Actor *)jarg1;
30837   {
30838     try {
30839       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30840     } catch (std::out_of_range& e) {
30841       {
30842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30843       };
30844     } catch (std::exception& e) {
30845       {
30846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30847       };
30848     } catch (...) {
30849       {
30850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30851       };
30852     }
30853   }
30854   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30855   return jresult;
30856 }
30857
30858
30859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30860   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30861   float arg2 ;
30862
30863   arg1 = (Dali::Actor *)jarg1;
30864   arg2 = (float)jarg2;
30865   {
30866     try {
30867       (arg1)->SetScale(arg2);
30868     } catch (std::out_of_range& e) {
30869       {
30870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30871       };
30872     } catch (std::exception& e) {
30873       {
30874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30875       };
30876     } catch (...) {
30877       {
30878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30879       };
30880     }
30881   }
30882 }
30883
30884
30885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30887   float arg2 ;
30888   float arg3 ;
30889   float arg4 ;
30890
30891   arg1 = (Dali::Actor *)jarg1;
30892   arg2 = (float)jarg2;
30893   arg3 = (float)jarg3;
30894   arg4 = (float)jarg4;
30895   {
30896     try {
30897       (arg1)->SetScale(arg2,arg3,arg4);
30898     } catch (std::out_of_range& e) {
30899       {
30900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30901       };
30902     } catch (std::exception& e) {
30903       {
30904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30905       };
30906     } catch (...) {
30907       {
30908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30909       };
30910     }
30911   }
30912 }
30913
30914
30915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30917   Dali::Vector3 *arg2 = 0 ;
30918
30919   arg1 = (Dali::Actor *)jarg1;
30920   arg2 = (Dali::Vector3 *)jarg2;
30921   if (!arg2) {
30922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30923     return ;
30924   }
30925   {
30926     try {
30927       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30928     } catch (std::out_of_range& e) {
30929       {
30930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30931       };
30932     } catch (std::exception& e) {
30933       {
30934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30935       };
30936     } catch (...) {
30937       {
30938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30939       };
30940     }
30941   }
30942 }
30943
30944
30945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30947   Dali::Vector3 *arg2 = 0 ;
30948
30949   arg1 = (Dali::Actor *)jarg1;
30950   arg2 = (Dali::Vector3 *)jarg2;
30951   if (!arg2) {
30952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30953     return ;
30954   }
30955   {
30956     try {
30957       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30958     } catch (std::out_of_range& e) {
30959       {
30960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30961       };
30962     } catch (std::exception& e) {
30963       {
30964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30965       };
30966     } catch (...) {
30967       {
30968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30969       };
30970     }
30971   }
30972 }
30973
30974
30975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30976   void * jresult ;
30977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30978   Dali::Vector3 result;
30979
30980   arg1 = (Dali::Actor *)jarg1;
30981   {
30982     try {
30983       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30984     } catch (std::out_of_range& e) {
30985       {
30986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30987       };
30988     } catch (std::exception& e) {
30989       {
30990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30991       };
30992     } catch (...) {
30993       {
30994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30995       };
30996     }
30997   }
30998   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30999   return jresult;
31000 }
31001
31002
31003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31004   void * jresult ;
31005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31006   Dali::Vector3 result;
31007
31008   arg1 = (Dali::Actor *)jarg1;
31009   {
31010     try {
31011       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31012     } catch (std::out_of_range& e) {
31013       {
31014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31015       };
31016     } catch (std::exception& e) {
31017       {
31018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31019       };
31020     } catch (...) {
31021       {
31022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31023       };
31024     }
31025   }
31026   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31027   return jresult;
31028 }
31029
31030
31031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31033   bool arg2 ;
31034
31035   arg1 = (Dali::Actor *)jarg1;
31036   arg2 = jarg2 ? true : false;
31037   {
31038     try {
31039       (arg1)->SetInheritScale(arg2);
31040     } catch (std::out_of_range& e) {
31041       {
31042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31043       };
31044     } catch (std::exception& e) {
31045       {
31046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31047       };
31048     } catch (...) {
31049       {
31050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31051       };
31052     }
31053   }
31054 }
31055
31056
31057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31058   unsigned int jresult ;
31059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31060   bool result;
31061
31062   arg1 = (Dali::Actor *)jarg1;
31063   {
31064     try {
31065       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31066     } catch (std::out_of_range& e) {
31067       {
31068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31069       };
31070     } catch (std::exception& e) {
31071       {
31072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31073       };
31074     } catch (...) {
31075       {
31076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31077       };
31078     }
31079   }
31080   jresult = result;
31081   return jresult;
31082 }
31083
31084
31085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31086   void * jresult ;
31087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31088   Dali::Matrix result;
31089
31090   arg1 = (Dali::Actor *)jarg1;
31091   {
31092     try {
31093       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31094     } catch (std::out_of_range& e) {
31095       {
31096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31097       };
31098     } catch (std::exception& e) {
31099       {
31100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31101       };
31102     } catch (...) {
31103       {
31104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31105       };
31106     }
31107   }
31108   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31109   return jresult;
31110 }
31111
31112
31113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31115   bool arg2 ;
31116
31117   arg1 = (Dali::Actor *)jarg1;
31118   arg2 = jarg2 ? true : false;
31119   {
31120     try {
31121       (arg1)->SetVisible(arg2);
31122     } catch (std::out_of_range& e) {
31123       {
31124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31125       };
31126     } catch (std::exception& e) {
31127       {
31128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31129       };
31130     } catch (...) {
31131       {
31132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31133       };
31134     }
31135   }
31136 }
31137
31138
31139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31140   unsigned int jresult ;
31141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31142   bool result;
31143
31144   arg1 = (Dali::Actor *)jarg1;
31145   {
31146     try {
31147       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31148     } catch (std::out_of_range& e) {
31149       {
31150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31151       };
31152     } catch (std::exception& e) {
31153       {
31154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31155       };
31156     } catch (...) {
31157       {
31158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31159       };
31160     }
31161   }
31162   jresult = result;
31163   return jresult;
31164 }
31165
31166
31167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31168   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31169   float arg2 ;
31170
31171   arg1 = (Dali::Actor *)jarg1;
31172   arg2 = (float)jarg2;
31173   {
31174     try {
31175       (arg1)->SetOpacity(arg2);
31176     } catch (std::out_of_range& e) {
31177       {
31178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31179       };
31180     } catch (std::exception& e) {
31181       {
31182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31183       };
31184     } catch (...) {
31185       {
31186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31187       };
31188     }
31189   }
31190 }
31191
31192
31193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31194   float jresult ;
31195   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31196   float result;
31197
31198   arg1 = (Dali::Actor *)jarg1;
31199   {
31200     try {
31201       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31202     } catch (std::out_of_range& e) {
31203       {
31204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31205       };
31206     } catch (std::exception& e) {
31207       {
31208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31209       };
31210     } catch (...) {
31211       {
31212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31213       };
31214     }
31215   }
31216   jresult = result;
31217   return jresult;
31218 }
31219
31220
31221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31222   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31223   Dali::Vector4 *arg2 = 0 ;
31224
31225   arg1 = (Dali::Actor *)jarg1;
31226   arg2 = (Dali::Vector4 *)jarg2;
31227   if (!arg2) {
31228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31229     return ;
31230   }
31231   {
31232     try {
31233       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31234     } catch (std::out_of_range& e) {
31235       {
31236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31237       };
31238     } catch (std::exception& e) {
31239       {
31240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31241       };
31242     } catch (...) {
31243       {
31244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31245       };
31246     }
31247   }
31248 }
31249
31250
31251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31252   void * jresult ;
31253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31254   Dali::Vector4 result;
31255
31256   arg1 = (Dali::Actor *)jarg1;
31257   {
31258     try {
31259       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31260     } catch (std::out_of_range& e) {
31261       {
31262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31263       };
31264     } catch (std::exception& e) {
31265       {
31266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (...) {
31269       {
31270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31271       };
31272     }
31273   }
31274   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31275   return jresult;
31276 }
31277
31278
31279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31281   Dali::ColorMode arg2 ;
31282
31283   arg1 = (Dali::Actor *)jarg1;
31284   arg2 = (Dali::ColorMode)jarg2;
31285   {
31286     try {
31287       (arg1)->SetColorMode(arg2);
31288     } catch (std::out_of_range& e) {
31289       {
31290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31291       };
31292     } catch (std::exception& e) {
31293       {
31294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31295       };
31296     } catch (...) {
31297       {
31298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31299       };
31300     }
31301   }
31302 }
31303
31304
31305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31306   int jresult ;
31307   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31308   Dali::ColorMode result;
31309
31310   arg1 = (Dali::Actor *)jarg1;
31311   {
31312     try {
31313       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31314     } catch (std::out_of_range& e) {
31315       {
31316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31317       };
31318     } catch (std::exception& e) {
31319       {
31320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31321       };
31322     } catch (...) {
31323       {
31324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31325       };
31326     }
31327   }
31328   jresult = (int)result;
31329   return jresult;
31330 }
31331
31332
31333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31334   void * jresult ;
31335   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31336   Dali::Vector4 result;
31337
31338   arg1 = (Dali::Actor *)jarg1;
31339   {
31340     try {
31341       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31342     } catch (std::out_of_range& e) {
31343       {
31344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31345       };
31346     } catch (std::exception& e) {
31347       {
31348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31349       };
31350     } catch (...) {
31351       {
31352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31353       };
31354     }
31355   }
31356   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31357   return jresult;
31358 }
31359
31360
31361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31362   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31363   Dali::DrawMode::Type arg2 ;
31364
31365   arg1 = (Dali::Actor *)jarg1;
31366   arg2 = (Dali::DrawMode::Type)jarg2;
31367   {
31368     try {
31369       (arg1)->SetDrawMode(arg2);
31370     } catch (std::out_of_range& e) {
31371       {
31372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31373       };
31374     } catch (std::exception& e) {
31375       {
31376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31377       };
31378     } catch (...) {
31379       {
31380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31381       };
31382     }
31383   }
31384 }
31385
31386
31387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31388   int jresult ;
31389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31390   Dali::DrawMode::Type result;
31391
31392   arg1 = (Dali::Actor *)jarg1;
31393   {
31394     try {
31395       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31396     } catch (std::out_of_range& e) {
31397       {
31398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31399       };
31400     } catch (std::exception& e) {
31401       {
31402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31403       };
31404     } catch (...) {
31405       {
31406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31407       };
31408     }
31409   }
31410   jresult = (int)result;
31411   return jresult;
31412 }
31413
31414
31415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31417   bool arg2 ;
31418
31419   arg1 = (Dali::Actor *)jarg1;
31420   arg2 = jarg2 ? true : false;
31421   {
31422     try {
31423       (arg1)->SetSensitive(arg2);
31424     } catch (std::out_of_range& e) {
31425       {
31426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31427       };
31428     } catch (std::exception& e) {
31429       {
31430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31431       };
31432     } catch (...) {
31433       {
31434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31435       };
31436     }
31437   }
31438 }
31439
31440
31441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31442   unsigned int jresult ;
31443   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31444   bool result;
31445
31446   arg1 = (Dali::Actor *)jarg1;
31447   {
31448     try {
31449       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31450     } catch (std::out_of_range& e) {
31451       {
31452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31453       };
31454     } catch (std::exception& e) {
31455       {
31456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31457       };
31458     } catch (...) {
31459       {
31460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31461       };
31462     }
31463   }
31464   jresult = result;
31465   return jresult;
31466 }
31467
31468
31469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31470   unsigned int jresult ;
31471   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31472   float *arg2 = 0 ;
31473   float *arg3 = 0 ;
31474   float arg4 ;
31475   float arg5 ;
31476   bool result;
31477
31478   arg1 = (Dali::Actor *)jarg1;
31479   arg2 = (float *)jarg2;
31480   arg3 = (float *)jarg3;
31481   arg4 = (float)jarg4;
31482   arg5 = (float)jarg5;
31483   {
31484     try {
31485       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31486     } catch (std::out_of_range& e) {
31487       {
31488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31489       };
31490     } catch (std::exception& e) {
31491       {
31492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31493       };
31494     } catch (...) {
31495       {
31496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31497       };
31498     }
31499   }
31500   jresult = result;
31501   return jresult;
31502 }
31503
31504
31505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31506   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31507   bool arg2 ;
31508
31509   arg1 = (Dali::Actor *)jarg1;
31510   arg2 = jarg2 ? true : false;
31511   {
31512     try {
31513       (arg1)->SetLeaveRequired(arg2);
31514     } catch (std::out_of_range& e) {
31515       {
31516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31517       };
31518     } catch (std::exception& e) {
31519       {
31520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31521       };
31522     } catch (...) {
31523       {
31524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31525       };
31526     }
31527   }
31528 }
31529
31530
31531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31532   unsigned int jresult ;
31533   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31534   bool result;
31535
31536   arg1 = (Dali::Actor *)jarg1;
31537   {
31538     try {
31539       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31540     } catch (std::out_of_range& e) {
31541       {
31542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31543       };
31544     } catch (std::exception& e) {
31545       {
31546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31547       };
31548     } catch (...) {
31549       {
31550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31551       };
31552     }
31553   }
31554   jresult = result;
31555   return jresult;
31556 }
31557
31558
31559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31560   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31561   bool arg2 ;
31562
31563   arg1 = (Dali::Actor *)jarg1;
31564   arg2 = jarg2 ? true : false;
31565   {
31566     try {
31567       (arg1)->SetKeyboardFocusable(arg2);
31568     } catch (std::out_of_range& e) {
31569       {
31570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31571       };
31572     } catch (std::exception& e) {
31573       {
31574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31575       };
31576     } catch (...) {
31577       {
31578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31579       };
31580     }
31581   }
31582 }
31583
31584
31585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31586   unsigned int jresult ;
31587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31588   bool result;
31589
31590   arg1 = (Dali::Actor *)jarg1;
31591   {
31592     try {
31593       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31594     } catch (std::out_of_range& e) {
31595       {
31596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31597       };
31598     } catch (std::exception& e) {
31599       {
31600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31601       };
31602     } catch (...) {
31603       {
31604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31605       };
31606     }
31607   }
31608   jresult = result;
31609   return jresult;
31610 }
31611
31612
31613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31615   Dali::ResizePolicy::Type arg2 ;
31616   Dali::Dimension::Type arg3 ;
31617
31618   arg1 = (Dali::Actor *)jarg1;
31619   arg2 = (Dali::ResizePolicy::Type)jarg2;
31620   arg3 = (Dali::Dimension::Type)jarg3;
31621   {
31622     try {
31623       (arg1)->SetResizePolicy(arg2,arg3);
31624     } catch (std::out_of_range& e) {
31625       {
31626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31627       };
31628     } catch (std::exception& e) {
31629       {
31630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31631       };
31632     } catch (...) {
31633       {
31634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31635       };
31636     }
31637   }
31638 }
31639
31640
31641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31642   int jresult ;
31643   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31644   Dali::Dimension::Type arg2 ;
31645   Dali::ResizePolicy::Type result;
31646
31647   arg1 = (Dali::Actor *)jarg1;
31648   arg2 = (Dali::Dimension::Type)jarg2;
31649   {
31650     try {
31651       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31652     } catch (std::out_of_range& e) {
31653       {
31654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31655       };
31656     } catch (std::exception& e) {
31657       {
31658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31659       };
31660     } catch (...) {
31661       {
31662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31663       };
31664     }
31665   }
31666   jresult = (int)result;
31667   return jresult;
31668 }
31669
31670
31671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31673   Dali::SizeScalePolicy::Type arg2 ;
31674
31675   arg1 = (Dali::Actor *)jarg1;
31676   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31677   {
31678     try {
31679       (arg1)->SetSizeScalePolicy(arg2);
31680     } catch (std::out_of_range& e) {
31681       {
31682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31683       };
31684     } catch (std::exception& e) {
31685       {
31686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31687       };
31688     } catch (...) {
31689       {
31690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31691       };
31692     }
31693   }
31694 }
31695
31696
31697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31698   int jresult ;
31699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31700   Dali::SizeScalePolicy::Type result;
31701
31702   arg1 = (Dali::Actor *)jarg1;
31703   {
31704     try {
31705       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31706     } catch (std::out_of_range& e) {
31707       {
31708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (std::exception& e) {
31711       {
31712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31713       };
31714     } catch (...) {
31715       {
31716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31717       };
31718     }
31719   }
31720   jresult = (int)result;
31721   return jresult;
31722 }
31723
31724
31725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31727   Dali::Vector3 *arg2 = 0 ;
31728
31729   arg1 = (Dali::Actor *)jarg1;
31730   arg2 = (Dali::Vector3 *)jarg2;
31731   if (!arg2) {
31732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31733     return ;
31734   }
31735   {
31736     try {
31737       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31738     } catch (std::out_of_range& e) {
31739       {
31740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31741       };
31742     } catch (std::exception& e) {
31743       {
31744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31745       };
31746     } catch (...) {
31747       {
31748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31749       };
31750     }
31751   }
31752 }
31753
31754
31755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31756   void * jresult ;
31757   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31758   Dali::Vector3 result;
31759
31760   arg1 = (Dali::Actor *)jarg1;
31761   {
31762     try {
31763       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31764     } catch (std::out_of_range& e) {
31765       {
31766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31767       };
31768     } catch (std::exception& e) {
31769       {
31770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31771       };
31772     } catch (...) {
31773       {
31774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31775       };
31776     }
31777   }
31778   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31779   return jresult;
31780 }
31781
31782
31783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31784   float jresult ;
31785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31786   float arg2 ;
31787   float result;
31788
31789   arg1 = (Dali::Actor *)jarg1;
31790   arg2 = (float)jarg2;
31791   {
31792     try {
31793       result = (float)(arg1)->GetHeightForWidth(arg2);
31794     } catch (std::out_of_range& e) {
31795       {
31796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31797       };
31798     } catch (std::exception& e) {
31799       {
31800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31801       };
31802     } catch (...) {
31803       {
31804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31805       };
31806     }
31807   }
31808   jresult = result;
31809   return jresult;
31810 }
31811
31812
31813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31814   float jresult ;
31815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31816   float arg2 ;
31817   float result;
31818
31819   arg1 = (Dali::Actor *)jarg1;
31820   arg2 = (float)jarg2;
31821   {
31822     try {
31823       result = (float)(arg1)->GetWidthForHeight(arg2);
31824     } catch (std::out_of_range& e) {
31825       {
31826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31827       };
31828     } catch (std::exception& e) {
31829       {
31830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31831       };
31832     } catch (...) {
31833       {
31834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31835       };
31836     }
31837   }
31838   jresult = result;
31839   return jresult;
31840 }
31841
31842
31843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31844   float jresult ;
31845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31846   Dali::Dimension::Type arg2 ;
31847   float result;
31848
31849   arg1 = (Dali::Actor *)jarg1;
31850   arg2 = (Dali::Dimension::Type)jarg2;
31851   {
31852     try {
31853       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31854     } catch (std::out_of_range& e) {
31855       {
31856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31857       };
31858     } catch (std::exception& e) {
31859       {
31860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31861       };
31862     } catch (...) {
31863       {
31864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31865       };
31866     }
31867   }
31868   jresult = result;
31869   return jresult;
31870 }
31871
31872
31873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31875   Dali::Padding *arg2 = 0 ;
31876
31877   arg1 = (Dali::Actor *)jarg1;
31878   arg2 = (Dali::Padding *)jarg2;
31879   if (!arg2) {
31880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31881     return ;
31882   }
31883   {
31884     try {
31885       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31886     } catch (std::out_of_range& e) {
31887       {
31888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31889       };
31890     } catch (std::exception& e) {
31891       {
31892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31893       };
31894     } catch (...) {
31895       {
31896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31897       };
31898     }
31899   }
31900 }
31901
31902
31903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31905   Dali::Padding *arg2 = 0 ;
31906
31907   arg1 = (Dali::Actor *)jarg1;
31908   arg2 = (Dali::Padding *)jarg2;
31909   if (!arg2) {
31910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31911     return ;
31912   }
31913   {
31914     try {
31915       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31916     } catch (std::out_of_range& e) {
31917       {
31918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31919       };
31920     } catch (std::exception& e) {
31921       {
31922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31923       };
31924     } catch (...) {
31925       {
31926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31927       };
31928     }
31929   }
31930 }
31931
31932
31933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31935   Dali::Vector2 *arg2 = 0 ;
31936
31937   arg1 = (Dali::Actor *)jarg1;
31938   arg2 = (Dali::Vector2 *)jarg2;
31939   if (!arg2) {
31940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31941     return ;
31942   }
31943   {
31944     try {
31945       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31946     } catch (std::out_of_range& e) {
31947       {
31948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31949       };
31950     } catch (std::exception& e) {
31951       {
31952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31953       };
31954     } catch (...) {
31955       {
31956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31957       };
31958     }
31959   }
31960 }
31961
31962
31963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31964   void * jresult ;
31965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31966   Dali::Vector2 result;
31967
31968   arg1 = (Dali::Actor *)jarg1;
31969   {
31970     try {
31971       result = (arg1)->GetMinimumSize();
31972     } catch (std::out_of_range& e) {
31973       {
31974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31975       };
31976     } catch (std::exception& e) {
31977       {
31978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31979       };
31980     } catch (...) {
31981       {
31982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31983       };
31984     }
31985   }
31986   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31987   return jresult;
31988 }
31989
31990
31991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31993   Dali::Vector2 *arg2 = 0 ;
31994
31995   arg1 = (Dali::Actor *)jarg1;
31996   arg2 = (Dali::Vector2 *)jarg2;
31997   if (!arg2) {
31998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31999     return ;
32000   }
32001   {
32002     try {
32003       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32004     } catch (std::out_of_range& e) {
32005       {
32006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32007       };
32008     } catch (std::exception& e) {
32009       {
32010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32011       };
32012     } catch (...) {
32013       {
32014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32015       };
32016     }
32017   }
32018 }
32019
32020
32021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32022   void * jresult ;
32023   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32024   Dali::Vector2 result;
32025
32026   arg1 = (Dali::Actor *)jarg1;
32027   {
32028     try {
32029       result = (arg1)->GetMaximumSize();
32030     } catch (std::out_of_range& e) {
32031       {
32032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32033       };
32034     } catch (std::exception& e) {
32035       {
32036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32037       };
32038     } catch (...) {
32039       {
32040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32041       };
32042     }
32043   }
32044   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32045   return jresult;
32046 }
32047
32048
32049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32050   int jresult ;
32051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32052   int result;
32053
32054   arg1 = (Dali::Actor *)jarg1;
32055   {
32056     try {
32057       result = (int)(arg1)->GetHierarchyDepth();
32058     } catch (std::out_of_range& e) {
32059       {
32060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32061       };
32062     } catch (std::exception& e) {
32063       {
32064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32065       };
32066     } catch (...) {
32067       {
32068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32069       };
32070     }
32071   }
32072   jresult = result;
32073   return jresult;
32074 }
32075
32076
32077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32078   unsigned int jresult ;
32079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32080   Dali::Renderer *arg2 = 0 ;
32081   unsigned int result;
32082
32083   arg1 = (Dali::Actor *)jarg1;
32084   arg2 = (Dali::Renderer *)jarg2;
32085   if (!arg2) {
32086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32087     return 0;
32088   }
32089   {
32090     try {
32091       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32092     } catch (std::out_of_range& e) {
32093       {
32094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32095       };
32096     } catch (std::exception& e) {
32097       {
32098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32099       };
32100     } catch (...) {
32101       {
32102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32103       };
32104     }
32105   }
32106   jresult = result;
32107   return jresult;
32108 }
32109
32110
32111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32112   unsigned int jresult ;
32113   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32114   unsigned int result;
32115
32116   arg1 = (Dali::Actor *)jarg1;
32117   {
32118     try {
32119       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32120     } catch (std::out_of_range& e) {
32121       {
32122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32123       };
32124     } catch (std::exception& e) {
32125       {
32126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32127       };
32128     } catch (...) {
32129       {
32130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32131       };
32132     }
32133   }
32134   jresult = result;
32135   return jresult;
32136 }
32137
32138
32139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32140   void * jresult ;
32141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32142   unsigned int arg2 ;
32143   Dali::Renderer result;
32144
32145   arg1 = (Dali::Actor *)jarg1;
32146   arg2 = (unsigned int)jarg2;
32147   {
32148     try {
32149       result = (arg1)->GetRendererAt(arg2);
32150     } catch (std::out_of_range& e) {
32151       {
32152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32153       };
32154     } catch (std::exception& e) {
32155       {
32156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32157       };
32158     } catch (...) {
32159       {
32160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32161       };
32162     }
32163   }
32164   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32165   return jresult;
32166 }
32167
32168
32169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32170   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32171   Dali::Renderer *arg2 = 0 ;
32172
32173   arg1 = (Dali::Actor *)jarg1;
32174   arg2 = (Dali::Renderer *)jarg2;
32175   if (!arg2) {
32176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32177     return ;
32178   }
32179   {
32180     try {
32181       (arg1)->RemoveRenderer(*arg2);
32182     } catch (std::out_of_range& e) {
32183       {
32184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32185       };
32186     } catch (std::exception& e) {
32187       {
32188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32189       };
32190     } catch (...) {
32191       {
32192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32193       };
32194     }
32195   }
32196 }
32197
32198
32199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32200   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32201   unsigned int arg2 ;
32202
32203   arg1 = (Dali::Actor *)jarg1;
32204   arg2 = (unsigned int)jarg2;
32205   {
32206     try {
32207       (arg1)->RemoveRenderer(arg2);
32208     } catch (std::out_of_range& e) {
32209       {
32210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32211       };
32212     } catch (std::exception& e) {
32213       {
32214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32215       };
32216     } catch (...) {
32217       {
32218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32219       };
32220     }
32221   }
32222 }
32223
32224
32225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32226   void * jresult ;
32227   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32228   Dali::Actor::TouchSignalType *result = 0 ;
32229
32230   arg1 = (Dali::Actor *)jarg1;
32231   {
32232     try {
32233       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32234     } catch (std::out_of_range& e) {
32235       {
32236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32237       };
32238     } catch (std::exception& e) {
32239       {
32240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32241       };
32242     } catch (...) {
32243       {
32244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32245       };
32246     }
32247   }
32248   jresult = (void *)result;
32249   return jresult;
32250 }
32251
32252
32253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32254   void * jresult ;
32255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32256   Dali::Actor::TouchDataSignalType *result = 0 ;
32257
32258   arg1 = (Dali::Actor *)jarg1;
32259   {
32260     try {
32261       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32262     } catch (std::out_of_range& e) {
32263       {
32264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32265       };
32266     } catch (std::exception& e) {
32267       {
32268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32269       };
32270     } catch (...) {
32271       {
32272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32273       };
32274     }
32275   }
32276   jresult = (void *)result;
32277   return jresult;
32278 }
32279
32280
32281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32282   void * jresult ;
32283   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32284   Dali::Actor::HoverSignalType *result = 0 ;
32285
32286   arg1 = (Dali::Actor *)jarg1;
32287   {
32288     try {
32289       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32290     } catch (std::out_of_range& e) {
32291       {
32292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32293       };
32294     } catch (std::exception& e) {
32295       {
32296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32297       };
32298     } catch (...) {
32299       {
32300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32301       };
32302     }
32303   }
32304   jresult = (void *)result;
32305   return jresult;
32306 }
32307
32308
32309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32310   void * jresult ;
32311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32312   Dali::Actor::WheelEventSignalType *result = 0 ;
32313
32314   arg1 = (Dali::Actor *)jarg1;
32315   {
32316     try {
32317       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32318     } catch (std::out_of_range& e) {
32319       {
32320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32321       };
32322     } catch (std::exception& e) {
32323       {
32324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32325       };
32326     } catch (...) {
32327       {
32328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32329       };
32330     }
32331   }
32332   jresult = (void *)result;
32333   return jresult;
32334 }
32335
32336
32337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32338   void * jresult ;
32339   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32340   Dali::Actor::OnStageSignalType *result = 0 ;
32341
32342   arg1 = (Dali::Actor *)jarg1;
32343   {
32344     try {
32345       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32346     } catch (std::out_of_range& e) {
32347       {
32348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32349       };
32350     } catch (std::exception& e) {
32351       {
32352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32353       };
32354     } catch (...) {
32355       {
32356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32357       };
32358     }
32359   }
32360   jresult = (void *)result;
32361   return jresult;
32362 }
32363
32364
32365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32366   void * jresult ;
32367   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32368   Dali::Actor::OffStageSignalType *result = 0 ;
32369
32370   arg1 = (Dali::Actor *)jarg1;
32371   {
32372     try {
32373       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32374     } catch (std::out_of_range& e) {
32375       {
32376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32377       };
32378     } catch (std::exception& e) {
32379       {
32380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32381       };
32382     } catch (...) {
32383       {
32384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32385       };
32386     }
32387   }
32388   jresult = (void *)result;
32389   return jresult;
32390 }
32391
32392
32393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32394   void * jresult ;
32395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32396   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32397
32398   arg1 = (Dali::Actor *)jarg1;
32399   {
32400     try {
32401       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32402     } catch (std::out_of_range& e) {
32403       {
32404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32405       };
32406     } catch (std::exception& e) {
32407       {
32408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32409       };
32410     } catch (...) {
32411       {
32412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32413       };
32414     }
32415   }
32416   jresult = (void *)result;
32417   return jresult;
32418 }
32419
32420
32421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32422   Dali::Actor *arg1 = 0 ;
32423
32424   arg1 = (Dali::Actor *)jarg1;
32425   if (!arg1) {
32426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32427     return ;
32428   }
32429   {
32430     try {
32431       Dali::UnparentAndReset(*arg1);
32432     } catch (std::out_of_range& e) {
32433       {
32434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32435       };
32436     } catch (std::exception& e) {
32437       {
32438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32439       };
32440     } catch (...) {
32441       {
32442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32443       };
32444     }
32445   }
32446 }
32447
32448
32449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32450   int jresult ;
32451   int result;
32452
32453   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32454   jresult = (int)result;
32455   return jresult;
32456 }
32457
32458
32459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32460   int jresult ;
32461   int result;
32462
32463   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32464   jresult = (int)result;
32465   return jresult;
32466 }
32467
32468
32469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32470   int jresult ;
32471   int result;
32472
32473   result = (int)Dali::Layer::Property::BEHAVIOR;
32474   jresult = (int)result;
32475   return jresult;
32476 }
32477
32478
32479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32480   void * jresult ;
32481   Dali::Layer::Property *result = 0 ;
32482
32483   {
32484     try {
32485       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32486     } catch (std::out_of_range& e) {
32487       {
32488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32489       };
32490     } catch (std::exception& e) {
32491       {
32492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32493       };
32494     } catch (...) {
32495       {
32496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32497       };
32498     }
32499   }
32500   jresult = (void *)result;
32501   return jresult;
32502 }
32503
32504
32505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32506   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32507
32508   arg1 = (Dali::Layer::Property *)jarg1;
32509   {
32510     try {
32511       delete arg1;
32512     } catch (std::out_of_range& e) {
32513       {
32514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32515       };
32516     } catch (std::exception& e) {
32517       {
32518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32519       };
32520     } catch (...) {
32521       {
32522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32523       };
32524     }
32525   }
32526 }
32527
32528
32529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32530   void * jresult ;
32531   Dali::Layer *result = 0 ;
32532
32533   {
32534     try {
32535       result = (Dali::Layer *)new Dali::Layer();
32536     } catch (std::out_of_range& e) {
32537       {
32538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32539       };
32540     } catch (std::exception& e) {
32541       {
32542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32543       };
32544     } catch (...) {
32545       {
32546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32547       };
32548     }
32549   }
32550   jresult = (void *)result;
32551   return jresult;
32552 }
32553
32554
32555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32556   void * jresult ;
32557   Dali::Layer result;
32558
32559   {
32560     try {
32561       result = Dali::Layer::New();
32562     } catch (std::out_of_range& e) {
32563       {
32564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32565       };
32566     } catch (std::exception& e) {
32567       {
32568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32569       };
32570     } catch (...) {
32571       {
32572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32573       };
32574     }
32575   }
32576   jresult = new Dali::Layer((const Dali::Layer &)result);
32577   return jresult;
32578 }
32579
32580
32581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32582   void * jresult ;
32583   Dali::BaseHandle arg1 ;
32584   Dali::BaseHandle *argp1 ;
32585   Dali::Layer result;
32586
32587   argp1 = (Dali::BaseHandle *)jarg1;
32588   if (!argp1) {
32589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32590     return 0;
32591   }
32592   arg1 = *argp1;
32593   {
32594     try {
32595       result = Dali::Layer::DownCast(arg1);
32596     } catch (std::out_of_range& e) {
32597       {
32598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32599       };
32600     } catch (std::exception& e) {
32601       {
32602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32603       };
32604     } catch (...) {
32605       {
32606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32607       };
32608     }
32609   }
32610   jresult = new Dali::Layer((const Dali::Layer &)result);
32611   return jresult;
32612 }
32613
32614
32615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32616   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32617
32618   arg1 = (Dali::Layer *)jarg1;
32619   {
32620     try {
32621       delete arg1;
32622     } catch (std::out_of_range& e) {
32623       {
32624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32625       };
32626     } catch (std::exception& e) {
32627       {
32628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32629       };
32630     } catch (...) {
32631       {
32632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32633       };
32634     }
32635   }
32636 }
32637
32638
32639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32640   void * jresult ;
32641   Dali::Layer *arg1 = 0 ;
32642   Dali::Layer *result = 0 ;
32643
32644   arg1 = (Dali::Layer *)jarg1;
32645   if (!arg1) {
32646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32647     return 0;
32648   }
32649   {
32650     try {
32651       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32652     } catch (std::out_of_range& e) {
32653       {
32654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32655       };
32656     } catch (std::exception& e) {
32657       {
32658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32659       };
32660     } catch (...) {
32661       {
32662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32663       };
32664     }
32665   }
32666   jresult = (void *)result;
32667   return jresult;
32668 }
32669
32670
32671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32672   void * jresult ;
32673   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32674   Dali::Layer *arg2 = 0 ;
32675   Dali::Layer *result = 0 ;
32676
32677   arg1 = (Dali::Layer *)jarg1;
32678   arg2 = (Dali::Layer *)jarg2;
32679   if (!arg2) {
32680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32681     return 0;
32682   }
32683   {
32684     try {
32685       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32686     } catch (std::out_of_range& e) {
32687       {
32688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32689       };
32690     } catch (std::exception& e) {
32691       {
32692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32693       };
32694     } catch (...) {
32695       {
32696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32697       };
32698     }
32699   }
32700   jresult = (void *)result;
32701   return jresult;
32702 }
32703
32704
32705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32706   unsigned int jresult ;
32707   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32708   unsigned int result;
32709
32710   arg1 = (Dali::Layer *)jarg1;
32711   {
32712     try {
32713       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32714     } catch (std::out_of_range& e) {
32715       {
32716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32717       };
32718     } catch (std::exception& e) {
32719       {
32720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32721       };
32722     } catch (...) {
32723       {
32724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32725       };
32726     }
32727   }
32728   jresult = result;
32729   return jresult;
32730 }
32731
32732
32733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32734   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32735
32736   arg1 = (Dali::Layer *)jarg1;
32737   {
32738     try {
32739       (arg1)->Raise();
32740     } catch (std::out_of_range& e) {
32741       {
32742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32743       };
32744     } catch (std::exception& e) {
32745       {
32746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32747       };
32748     } catch (...) {
32749       {
32750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32751       };
32752     }
32753   }
32754 }
32755
32756
32757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32758   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32759
32760   arg1 = (Dali::Layer *)jarg1;
32761   {
32762     try {
32763       (arg1)->Lower();
32764     } catch (std::out_of_range& e) {
32765       {
32766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32767       };
32768     } catch (std::exception& e) {
32769       {
32770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32771       };
32772     } catch (...) {
32773       {
32774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32775       };
32776     }
32777   }
32778 }
32779
32780
32781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32782   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32783   Dali::Layer arg2 ;
32784   Dali::Layer *argp2 ;
32785
32786   arg1 = (Dali::Layer *)jarg1;
32787   argp2 = (Dali::Layer *)jarg2;
32788   if (!argp2) {
32789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32790     return ;
32791   }
32792   arg2 = *argp2;
32793   {
32794     try {
32795       (arg1)->RaiseAbove(arg2);
32796     } catch (std::out_of_range& e) {
32797       {
32798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32799       };
32800     } catch (std::exception& e) {
32801       {
32802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32803       };
32804     } catch (...) {
32805       {
32806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32807       };
32808     }
32809   }
32810 }
32811
32812
32813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32814   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32815   Dali::Layer arg2 ;
32816   Dali::Layer *argp2 ;
32817
32818   arg1 = (Dali::Layer *)jarg1;
32819   argp2 = (Dali::Layer *)jarg2;
32820   if (!argp2) {
32821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32822     return ;
32823   }
32824   arg2 = *argp2;
32825   {
32826     try {
32827       (arg1)->LowerBelow(arg2);
32828     } catch (std::out_of_range& e) {
32829       {
32830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32831       };
32832     } catch (std::exception& e) {
32833       {
32834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32835       };
32836     } catch (...) {
32837       {
32838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32839       };
32840     }
32841   }
32842 }
32843
32844
32845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32846   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32847
32848   arg1 = (Dali::Layer *)jarg1;
32849   {
32850     try {
32851       (arg1)->RaiseToTop();
32852     } catch (std::out_of_range& e) {
32853       {
32854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32855       };
32856     } catch (std::exception& e) {
32857       {
32858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32859       };
32860     } catch (...) {
32861       {
32862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32863       };
32864     }
32865   }
32866 }
32867
32868
32869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32870   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32871
32872   arg1 = (Dali::Layer *)jarg1;
32873   {
32874     try {
32875       (arg1)->LowerToBottom();
32876     } catch (std::out_of_range& e) {
32877       {
32878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32879       };
32880     } catch (std::exception& e) {
32881       {
32882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32883       };
32884     } catch (...) {
32885       {
32886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32887       };
32888     }
32889   }
32890 }
32891
32892
32893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32894   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32895   Dali::Layer arg2 ;
32896   Dali::Layer *argp2 ;
32897
32898   arg1 = (Dali::Layer *)jarg1;
32899   argp2 = (Dali::Layer *)jarg2;
32900   if (!argp2) {
32901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32902     return ;
32903   }
32904   arg2 = *argp2;
32905   {
32906     try {
32907       (arg1)->MoveAbove(arg2);
32908     } catch (std::out_of_range& e) {
32909       {
32910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32911       };
32912     } catch (std::exception& e) {
32913       {
32914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32915       };
32916     } catch (...) {
32917       {
32918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32919       };
32920     }
32921   }
32922 }
32923
32924
32925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32926   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32927   Dali::Layer arg2 ;
32928   Dali::Layer *argp2 ;
32929
32930   arg1 = (Dali::Layer *)jarg1;
32931   argp2 = (Dali::Layer *)jarg2;
32932   if (!argp2) {
32933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32934     return ;
32935   }
32936   arg2 = *argp2;
32937   {
32938     try {
32939       (arg1)->MoveBelow(arg2);
32940     } catch (std::out_of_range& e) {
32941       {
32942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32943       };
32944     } catch (std::exception& e) {
32945       {
32946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32947       };
32948     } catch (...) {
32949       {
32950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32951       };
32952     }
32953   }
32954 }
32955
32956
32957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32958   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32959   Dali::Layer::Behavior arg2 ;
32960
32961   arg1 = (Dali::Layer *)jarg1;
32962   arg2 = (Dali::Layer::Behavior)jarg2;
32963   {
32964     try {
32965       (arg1)->SetBehavior(arg2);
32966     } catch (std::out_of_range& e) {
32967       {
32968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32969       };
32970     } catch (std::exception& e) {
32971       {
32972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32973       };
32974     } catch (...) {
32975       {
32976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32977       };
32978     }
32979   }
32980 }
32981
32982
32983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32984   int jresult ;
32985   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32986   Dali::Layer::Behavior result;
32987
32988   arg1 = (Dali::Layer *)jarg1;
32989   {
32990     try {
32991       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32992     } catch (std::out_of_range& e) {
32993       {
32994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32995       };
32996     } catch (std::exception& e) {
32997       {
32998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32999       };
33000     } catch (...) {
33001       {
33002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33003       };
33004     }
33005   }
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33012   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33013   bool arg2 ;
33014
33015   arg1 = (Dali::Layer *)jarg1;
33016   arg2 = jarg2 ? true : false;
33017   {
33018     try {
33019       (arg1)->SetClipping(arg2);
33020     } catch (std::out_of_range& e) {
33021       {
33022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33023       };
33024     } catch (std::exception& e) {
33025       {
33026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33027       };
33028     } catch (...) {
33029       {
33030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33031       };
33032     }
33033   }
33034 }
33035
33036
33037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33038   unsigned int jresult ;
33039   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33040   bool result;
33041
33042   arg1 = (Dali::Layer *)jarg1;
33043   {
33044     try {
33045       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33046     } catch (std::out_of_range& e) {
33047       {
33048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33049       };
33050     } catch (std::exception& e) {
33051       {
33052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33053       };
33054     } catch (...) {
33055       {
33056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33057       };
33058     }
33059   }
33060   jresult = result;
33061   return jresult;
33062 }
33063
33064
33065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33066   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33067   int arg2 ;
33068   int arg3 ;
33069   int arg4 ;
33070   int arg5 ;
33071
33072   arg1 = (Dali::Layer *)jarg1;
33073   arg2 = (int)jarg2;
33074   arg3 = (int)jarg3;
33075   arg4 = (int)jarg4;
33076   arg5 = (int)jarg5;
33077   {
33078     try {
33079       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33080     } catch (std::out_of_range& e) {
33081       {
33082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33083       };
33084     } catch (std::exception& e) {
33085       {
33086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33087       };
33088     } catch (...) {
33089       {
33090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33091       };
33092     }
33093   }
33094 }
33095
33096
33097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33098   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33099   Dali::ClippingBox arg2 ;
33100   Dali::ClippingBox *argp2 ;
33101
33102   arg1 = (Dali::Layer *)jarg1;
33103   argp2 = (Dali::ClippingBox *)jarg2;
33104   if (!argp2) {
33105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33106     return ;
33107   }
33108   arg2 = *argp2;
33109   {
33110     try {
33111       (arg1)->SetClippingBox(arg2);
33112     } catch (std::out_of_range& e) {
33113       {
33114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33115       };
33116     } catch (std::exception& e) {
33117       {
33118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33119       };
33120     } catch (...) {
33121       {
33122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33123       };
33124     }
33125   }
33126 }
33127
33128
33129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33130   void * jresult ;
33131   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33132   Dali::ClippingBox result;
33133
33134   arg1 = (Dali::Layer *)jarg1;
33135   {
33136     try {
33137       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33138     } catch (std::out_of_range& e) {
33139       {
33140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33141       };
33142     } catch (std::exception& e) {
33143       {
33144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33145       };
33146     } catch (...) {
33147       {
33148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33149       };
33150     }
33151   }
33152   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33153   return jresult;
33154 }
33155
33156
33157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33158   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33159   bool arg2 ;
33160
33161   arg1 = (Dali::Layer *)jarg1;
33162   arg2 = jarg2 ? true : false;
33163   {
33164     try {
33165       (arg1)->SetDepthTestDisabled(arg2);
33166     } catch (std::out_of_range& e) {
33167       {
33168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33169       };
33170     } catch (std::exception& e) {
33171       {
33172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33173       };
33174     } catch (...) {
33175       {
33176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33177       };
33178     }
33179   }
33180 }
33181
33182
33183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33184   unsigned int jresult ;
33185   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33186   bool result;
33187
33188   arg1 = (Dali::Layer *)jarg1;
33189   {
33190     try {
33191       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33192     } catch (std::out_of_range& e) {
33193       {
33194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33195       };
33196     } catch (std::exception& e) {
33197       {
33198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33199       };
33200     } catch (...) {
33201       {
33202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33203       };
33204     }
33205   }
33206   jresult = result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33212   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33213   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33214
33215   arg1 = (Dali::Layer *)jarg1;
33216   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33217   {
33218     try {
33219       (arg1)->SetSortFunction(arg2);
33220     } catch (std::out_of_range& e) {
33221       {
33222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33223       };
33224     } catch (std::exception& e) {
33225       {
33226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33227       };
33228     } catch (...) {
33229       {
33230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33231       };
33232     }
33233   }
33234 }
33235
33236
33237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33238   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33239   bool arg2 ;
33240
33241   arg1 = (Dali::Layer *)jarg1;
33242   arg2 = jarg2 ? true : false;
33243   {
33244     try {
33245       (arg1)->SetTouchConsumed(arg2);
33246     } catch (std::out_of_range& e) {
33247       {
33248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33249       };
33250     } catch (std::exception& e) {
33251       {
33252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33253       };
33254     } catch (...) {
33255       {
33256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33257       };
33258     }
33259   }
33260 }
33261
33262
33263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33264   unsigned int jresult ;
33265   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33266   bool result;
33267
33268   arg1 = (Dali::Layer *)jarg1;
33269   {
33270     try {
33271       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33272     } catch (std::out_of_range& e) {
33273       {
33274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33275       };
33276     } catch (std::exception& e) {
33277       {
33278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33279       };
33280     } catch (...) {
33281       {
33282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33283       };
33284     }
33285   }
33286   jresult = result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33292   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33293   bool arg2 ;
33294
33295   arg1 = (Dali::Layer *)jarg1;
33296   arg2 = jarg2 ? true : false;
33297   {
33298     try {
33299       (arg1)->SetHoverConsumed(arg2);
33300     } catch (std::out_of_range& e) {
33301       {
33302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33303       };
33304     } catch (std::exception& e) {
33305       {
33306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33307       };
33308     } catch (...) {
33309       {
33310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33311       };
33312     }
33313   }
33314 }
33315
33316
33317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33318   unsigned int jresult ;
33319   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33320   bool result;
33321
33322   arg1 = (Dali::Layer *)jarg1;
33323   {
33324     try {
33325       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33326     } catch (std::out_of_range& e) {
33327       {
33328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33329       };
33330     } catch (std::exception& e) {
33331       {
33332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33333       };
33334     } catch (...) {
33335       {
33336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33337       };
33338     }
33339   }
33340   jresult = result;
33341   return jresult;
33342 }
33343
33344
33345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33346   void * jresult ;
33347   Dali::Vector4 *result = 0 ;
33348
33349   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33350   jresult = (void *)result;
33351   return jresult;
33352 }
33353
33354
33355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33356   void * jresult ;
33357   Dali::Vector4 *result = 0 ;
33358
33359   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33360   jresult = (void *)result;
33361   return jresult;
33362 }
33363
33364
33365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33366   void * jresult ;
33367   Dali::Stage *result = 0 ;
33368
33369   {
33370     try {
33371       result = (Dali::Stage *)new Dali::Stage();
33372     } catch (std::out_of_range& e) {
33373       {
33374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33375       };
33376     } catch (std::exception& e) {
33377       {
33378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33379       };
33380     } catch (...) {
33381       {
33382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33383       };
33384     }
33385   }
33386   jresult = (void *)result;
33387   return jresult;
33388 }
33389
33390
33391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33392   void * jresult ;
33393   Dali::Stage result;
33394
33395   {
33396     try {
33397       result = Dali::Stage::GetCurrent();
33398     } catch (std::out_of_range& e) {
33399       {
33400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33401       };
33402     } catch (std::exception& e) {
33403       {
33404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33405       };
33406     } catch (...) {
33407       {
33408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33409       };
33410     }
33411   }
33412   jresult = new Dali::Stage((const Dali::Stage &)result);
33413   return jresult;
33414 }
33415
33416
33417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33418   unsigned int jresult ;
33419   bool result;
33420
33421   {
33422     try {
33423       result = (bool)Dali::Stage::IsInstalled();
33424     } catch (std::out_of_range& e) {
33425       {
33426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33427       };
33428     } catch (std::exception& e) {
33429       {
33430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33431       };
33432     } catch (...) {
33433       {
33434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33435       };
33436     }
33437   }
33438   jresult = result;
33439   return jresult;
33440 }
33441
33442
33443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33444   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33445
33446   arg1 = (Dali::Stage *)jarg1;
33447   {
33448     try {
33449       delete arg1;
33450     } catch (std::out_of_range& e) {
33451       {
33452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33453       };
33454     } catch (std::exception& e) {
33455       {
33456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33457       };
33458     } catch (...) {
33459       {
33460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33461       };
33462     }
33463   }
33464 }
33465
33466
33467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33468   void * jresult ;
33469   Dali::Stage *arg1 = 0 ;
33470   Dali::Stage *result = 0 ;
33471
33472   arg1 = (Dali::Stage *)jarg1;
33473   if (!arg1) {
33474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33475     return 0;
33476   }
33477   {
33478     try {
33479       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33480     } catch (std::out_of_range& e) {
33481       {
33482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33483       };
33484     } catch (std::exception& e) {
33485       {
33486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33487       };
33488     } catch (...) {
33489       {
33490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33491       };
33492     }
33493   }
33494   jresult = (void *)result;
33495   return jresult;
33496 }
33497
33498
33499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33500   void * jresult ;
33501   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33502   Dali::Stage *arg2 = 0 ;
33503   Dali::Stage *result = 0 ;
33504
33505   arg1 = (Dali::Stage *)jarg1;
33506   arg2 = (Dali::Stage *)jarg2;
33507   if (!arg2) {
33508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33509     return 0;
33510   }
33511   {
33512     try {
33513       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33514     } catch (std::out_of_range& e) {
33515       {
33516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33517       };
33518     } catch (std::exception& e) {
33519       {
33520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33521       };
33522     } catch (...) {
33523       {
33524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33525       };
33526     }
33527   }
33528   jresult = (void *)result;
33529   return jresult;
33530 }
33531
33532
33533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33534   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33535   Dali::Actor *arg2 = 0 ;
33536
33537   arg1 = (Dali::Stage *)jarg1;
33538   arg2 = (Dali::Actor *)jarg2;
33539   if (!arg2) {
33540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33541     return ;
33542   }
33543   {
33544     try {
33545       (arg1)->Add(*arg2);
33546     } catch (std::out_of_range& e) {
33547       {
33548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33549       };
33550     } catch (std::exception& e) {
33551       {
33552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33553       };
33554     } catch (...) {
33555       {
33556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33557       };
33558     }
33559   }
33560 }
33561
33562
33563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33564   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33565   Dali::Actor *arg2 = 0 ;
33566
33567   arg1 = (Dali::Stage *)jarg1;
33568   arg2 = (Dali::Actor *)jarg2;
33569   if (!arg2) {
33570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33571     return ;
33572   }
33573   {
33574     try {
33575       (arg1)->Remove(*arg2);
33576     } catch (std::out_of_range& e) {
33577       {
33578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33579       };
33580     } catch (std::exception& e) {
33581       {
33582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33583       };
33584     } catch (...) {
33585       {
33586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33587       };
33588     }
33589   }
33590 }
33591
33592
33593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33594   void * jresult ;
33595   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33596   Dali::Vector2 result;
33597
33598   arg1 = (Dali::Stage *)jarg1;
33599   {
33600     try {
33601       result = ((Dali::Stage const *)arg1)->GetSize();
33602     } catch (std::out_of_range& e) {
33603       {
33604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33605       };
33606     } catch (std::exception& e) {
33607       {
33608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33609       };
33610     } catch (...) {
33611       {
33612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33613       };
33614     }
33615   }
33616   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33617   return jresult;
33618 }
33619
33620
33621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33622   void * jresult ;
33623   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33624   Dali::RenderTaskList result;
33625
33626   arg1 = (Dali::Stage *)jarg1;
33627   {
33628     try {
33629       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33630     } catch (std::out_of_range& e) {
33631       {
33632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33633       };
33634     } catch (std::exception& e) {
33635       {
33636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33637       };
33638     } catch (...) {
33639       {
33640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33641       };
33642     }
33643   }
33644   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33645   return jresult;
33646 }
33647
33648
33649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33650   unsigned int jresult ;
33651   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33652   unsigned int result;
33653
33654   arg1 = (Dali::Stage *)jarg1;
33655   {
33656     try {
33657       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33658     } catch (std::out_of_range& e) {
33659       {
33660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33661       };
33662     } catch (std::exception& e) {
33663       {
33664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33665       };
33666     } catch (...) {
33667       {
33668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33669       };
33670     }
33671   }
33672   jresult = result;
33673   return jresult;
33674 }
33675
33676
33677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33678   void * jresult ;
33679   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33680   unsigned int arg2 ;
33681   Dali::Layer result;
33682
33683   arg1 = (Dali::Stage *)jarg1;
33684   arg2 = (unsigned int)jarg2;
33685   {
33686     try {
33687       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33688     } catch (std::out_of_range& e) {
33689       {
33690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33691       };
33692     } catch (std::exception& e) {
33693       {
33694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33695       };
33696     } catch (...) {
33697       {
33698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33699       };
33700     }
33701   }
33702   jresult = new Dali::Layer((const Dali::Layer &)result);
33703   return jresult;
33704 }
33705
33706
33707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33708   void * jresult ;
33709   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33710   Dali::Layer result;
33711
33712   arg1 = (Dali::Stage *)jarg1;
33713   {
33714     try {
33715       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33716     } catch (std::out_of_range& e) {
33717       {
33718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33719       };
33720     } catch (std::exception& e) {
33721       {
33722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33723       };
33724     } catch (...) {
33725       {
33726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33727       };
33728     }
33729   }
33730   jresult = new Dali::Layer((const Dali::Layer &)result);
33731   return jresult;
33732 }
33733
33734
33735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33736   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33737   Dali::Vector4 arg2 ;
33738   Dali::Vector4 *argp2 ;
33739
33740   arg1 = (Dali::Stage *)jarg1;
33741   argp2 = (Dali::Vector4 *)jarg2;
33742   if (!argp2) {
33743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33744     return ;
33745   }
33746   arg2 = *argp2;
33747   {
33748     try {
33749       (arg1)->SetBackgroundColor(arg2);
33750     } catch (std::out_of_range& e) {
33751       {
33752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33753       };
33754     } catch (std::exception& e) {
33755       {
33756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33757       };
33758     } catch (...) {
33759       {
33760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33761       };
33762     }
33763   }
33764 }
33765
33766
33767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33768   void * jresult ;
33769   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33770   Dali::Vector4 result;
33771
33772   arg1 = (Dali::Stage *)jarg1;
33773   {
33774     try {
33775       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33776     } catch (std::out_of_range& e) {
33777       {
33778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33779       };
33780     } catch (std::exception& e) {
33781       {
33782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33783       };
33784     } catch (...) {
33785       {
33786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33787       };
33788     }
33789   }
33790   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33791   return jresult;
33792 }
33793
33794
33795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33796   void * jresult ;
33797   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33798   Dali::Vector2 result;
33799
33800   arg1 = (Dali::Stage *)jarg1;
33801   {
33802     try {
33803       result = ((Dali::Stage const *)arg1)->GetDpi();
33804     } catch (std::out_of_range& e) {
33805       {
33806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33807       };
33808     } catch (std::exception& e) {
33809       {
33810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33811       };
33812     } catch (...) {
33813       {
33814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33815       };
33816     }
33817   }
33818   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33819   return jresult;
33820 }
33821
33822
33823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33824   void * jresult ;
33825   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33826   Dali::ObjectRegistry result;
33827
33828   arg1 = (Dali::Stage *)jarg1;
33829   {
33830     try {
33831       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33832     } catch (std::out_of_range& e) {
33833       {
33834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33835       };
33836     } catch (std::exception& e) {
33837       {
33838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33839       };
33840     } catch (...) {
33841       {
33842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33843       };
33844     }
33845   }
33846   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33847   return jresult;
33848 }
33849
33850
33851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33852   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33853   float arg2 ;
33854
33855   arg1 = (Dali::Stage *)jarg1;
33856   arg2 = (float)jarg2;
33857   {
33858     try {
33859       (arg1)->KeepRendering(arg2);
33860     } catch (std::out_of_range& e) {
33861       {
33862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33863       };
33864     } catch (std::exception& e) {
33865       {
33866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33867       };
33868     } catch (...) {
33869       {
33870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33871       };
33872     }
33873   }
33874 }
33875
33876
33877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33878   void * jresult ;
33879   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33880   Dali::Stage::KeyEventSignalType *result = 0 ;
33881
33882   arg1 = (Dali::Stage *)jarg1;
33883   {
33884     try {
33885       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33886     } catch (std::out_of_range& e) {
33887       {
33888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33889       };
33890     } catch (std::exception& e) {
33891       {
33892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33893       };
33894     } catch (...) {
33895       {
33896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33897       };
33898     }
33899   }
33900   jresult = (void *)result;
33901   return jresult;
33902 }
33903
33904
33905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33906   void * jresult ;
33907   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33908   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33909
33910   arg1 = (Dali::Stage *)jarg1;
33911   {
33912     try {
33913       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33914     } catch (std::out_of_range& e) {
33915       {
33916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33917       };
33918     } catch (std::exception& e) {
33919       {
33920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33921       };
33922     } catch (...) {
33923       {
33924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33925       };
33926     }
33927   }
33928   jresult = (void *)result;
33929   return jresult;
33930 }
33931
33932
33933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33934   void * jresult ;
33935   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33936   Dali::Stage::TouchSignalType *result = 0 ;
33937
33938   arg1 = (Dali::Stage *)jarg1;
33939   {
33940     try {
33941       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33942     } catch (std::out_of_range& e) {
33943       {
33944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33945       };
33946     } catch (std::exception& e) {
33947       {
33948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33949       };
33950     } catch (...) {
33951       {
33952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33953       };
33954     }
33955   }
33956   jresult = (void *)result;
33957   return jresult;
33958 }
33959
33960
33961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33962   void * jresult ;
33963   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33964   Dali::Stage::WheelEventSignalType *result = 0 ;
33965
33966   arg1 = (Dali::Stage *)jarg1;
33967   {
33968     try {
33969       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33970     } catch (std::out_of_range& e) {
33971       {
33972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33973       };
33974     } catch (std::exception& e) {
33975       {
33976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33977       };
33978     } catch (...) {
33979       {
33980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33981       };
33982     }
33983   }
33984   jresult = (void *)result;
33985   return jresult;
33986 }
33987
33988
33989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33990   void * jresult ;
33991   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33992   Dali::Stage::ContextStatusSignal *result = 0 ;
33993
33994   arg1 = (Dali::Stage *)jarg1;
33995   {
33996     try {
33997       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33998     } catch (std::out_of_range& e) {
33999       {
34000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34001       };
34002     } catch (std::exception& e) {
34003       {
34004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34005       };
34006     } catch (...) {
34007       {
34008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34009       };
34010     }
34011   }
34012   jresult = (void *)result;
34013   return jresult;
34014 }
34015
34016
34017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34018   void * jresult ;
34019   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34020   Dali::Stage::ContextStatusSignal *result = 0 ;
34021
34022   arg1 = (Dali::Stage *)jarg1;
34023   {
34024     try {
34025       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34026     } catch (std::out_of_range& e) {
34027       {
34028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34029       };
34030     } catch (std::exception& e) {
34031       {
34032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34033       };
34034     } catch (...) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34037       };
34038     }
34039   }
34040   jresult = (void *)result;
34041   return jresult;
34042 }
34043
34044
34045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34046   void * jresult ;
34047   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34048   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34049
34050   arg1 = (Dali::Stage *)jarg1;
34051   {
34052     try {
34053       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34054     } catch (std::out_of_range& e) {
34055       {
34056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34057       };
34058     } catch (std::exception& e) {
34059       {
34060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34061       };
34062     } catch (...) {
34063       {
34064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34065       };
34066     }
34067   }
34068   jresult = (void *)result;
34069   return jresult;
34070 }
34071
34072
34073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34074   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34075
34076   arg1 = (Dali::RelayoutContainer *)jarg1;
34077   {
34078     try {
34079       delete arg1;
34080     } catch (std::out_of_range& e) {
34081       {
34082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34083       };
34084     } catch (std::exception& e) {
34085       {
34086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34087       };
34088     } catch (...) {
34089       {
34090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34091       };
34092     }
34093   }
34094 }
34095
34096
34097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34098   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34099   Dali::Actor *arg2 = 0 ;
34100   Dali::Vector2 *arg3 = 0 ;
34101
34102   arg1 = (Dali::RelayoutContainer *)jarg1;
34103   arg2 = (Dali::Actor *)jarg2;
34104   if (!arg2) {
34105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34106     return ;
34107   }
34108   arg3 = (Dali::Vector2 *)jarg3;
34109   if (!arg3) {
34110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34111     return ;
34112   }
34113   {
34114     try {
34115       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34116     } catch (std::out_of_range& e) {
34117       {
34118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34119       };
34120     } catch (std::exception& e) {
34121       {
34122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34123       };
34124     } catch (...) {
34125       {
34126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34127       };
34128     }
34129   }
34130 }
34131
34132
34133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34134   void * jresult ;
34135   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34136   Dali::CustomActor result;
34137
34138   arg1 = (Dali::CustomActorImpl *)jarg1;
34139   {
34140     try {
34141       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34142     } catch (std::out_of_range& e) {
34143       {
34144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34145       };
34146     } catch (std::exception& e) {
34147       {
34148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34149       };
34150     } catch (...) {
34151       {
34152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34153       };
34154     }
34155   }
34156   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34157   return jresult;
34158 }
34159
34160
34161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34162   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34163   int arg2 ;
34164
34165   arg1 = (Dali::CustomActorImpl *)jarg1;
34166   arg2 = (int)jarg2;
34167   {
34168     try {
34169       (arg1)->OnStageConnection(arg2);
34170     } catch (std::out_of_range& e) {
34171       {
34172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34173       };
34174     } catch (std::exception& e) {
34175       {
34176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34177       };
34178     } catch (...) {
34179       {
34180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34181       };
34182     }
34183   }
34184 }
34185
34186
34187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34188   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34189
34190   arg1 = (Dali::CustomActorImpl *)jarg1;
34191   {
34192     try {
34193       (arg1)->OnStageDisconnection();
34194     } catch (std::out_of_range& e) {
34195       {
34196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34197       };
34198     } catch (std::exception& e) {
34199       {
34200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34201       };
34202     } catch (...) {
34203       {
34204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34205       };
34206     }
34207   }
34208 }
34209
34210
34211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34212   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34213   Dali::Actor *arg2 = 0 ;
34214
34215   arg1 = (Dali::CustomActorImpl *)jarg1;
34216   arg2 = (Dali::Actor *)jarg2;
34217   if (!arg2) {
34218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34219     return ;
34220   }
34221   {
34222     try {
34223       (arg1)->OnChildAdd(*arg2);
34224     } catch (std::out_of_range& e) {
34225       {
34226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34227       };
34228     } catch (std::exception& e) {
34229       {
34230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34231       };
34232     } catch (...) {
34233       {
34234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34235       };
34236     }
34237   }
34238 }
34239
34240
34241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34242   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34243   Dali::Actor *arg2 = 0 ;
34244
34245   arg1 = (Dali::CustomActorImpl *)jarg1;
34246   arg2 = (Dali::Actor *)jarg2;
34247   if (!arg2) {
34248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34249     return ;
34250   }
34251   {
34252     try {
34253       (arg1)->OnChildRemove(*arg2);
34254     } catch (std::out_of_range& e) {
34255       {
34256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34257       };
34258     } catch (std::exception& e) {
34259       {
34260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34261       };
34262     } catch (...) {
34263       {
34264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34265       };
34266     }
34267   }
34268 }
34269
34270
34271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34272   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34273   Dali::Property::Index arg2 ;
34274   Dali::Property::Value arg3 ;
34275   Dali::Property::Value *argp3 ;
34276
34277   arg1 = (Dali::CustomActorImpl *)jarg1;
34278   arg2 = (Dali::Property::Index)jarg2;
34279   argp3 = (Dali::Property::Value *)jarg3;
34280   if (!argp3) {
34281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34282     return ;
34283   }
34284   arg3 = *argp3;
34285   {
34286     try {
34287       (arg1)->OnPropertySet(arg2,arg3);
34288     } catch (std::out_of_range& e) {
34289       {
34290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34291       };
34292     } catch (std::exception& e) {
34293       {
34294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34295       };
34296     } catch (...) {
34297       {
34298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34299       };
34300     }
34301   }
34302 }
34303
34304
34305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34306   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34307   Dali::Vector3 *arg2 = 0 ;
34308
34309   arg1 = (Dali::CustomActorImpl *)jarg1;
34310   arg2 = (Dali::Vector3 *)jarg2;
34311   if (!arg2) {
34312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34313     return ;
34314   }
34315   {
34316     try {
34317       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34318     } catch (std::out_of_range& e) {
34319       {
34320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34321       };
34322     } catch (std::exception& e) {
34323       {
34324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34325       };
34326     } catch (...) {
34327       {
34328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34329       };
34330     }
34331   }
34332 }
34333
34334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34335   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34336   Dali::Animation *arg2 = 0 ;
34337   Dali::Vector3 *arg3 = 0 ;
34338
34339   arg1 = (Dali::CustomActorImpl *)jarg1;
34340   arg2 = (Dali::Animation *)jarg2;
34341   if (!arg2) {
34342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34343     return ;
34344   }
34345   arg3 = (Dali::Vector3 *)jarg3;
34346   if (!arg3) {
34347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34348     return ;
34349   }
34350   {
34351     try {
34352       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34353     } catch (std::out_of_range& e) {
34354       {
34355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34356       };
34357     } catch (std::exception& e) {
34358       {
34359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34360       };
34361     } catch (...) {
34362       {
34363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34364       };
34365     }
34366   }
34367 }
34368
34369
34370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34371   unsigned int jresult ;
34372   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34373   Dali::TouchEvent *arg2 = 0 ;
34374   bool result;
34375
34376   arg1 = (Dali::CustomActorImpl *)jarg1;
34377   arg2 = (Dali::TouchEvent *)jarg2;
34378   if (!arg2) {
34379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34380     return 0;
34381   }
34382   {
34383     try {
34384       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34385     } catch (std::out_of_range& e) {
34386       {
34387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34388       };
34389     } catch (std::exception& e) {
34390       {
34391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34392       };
34393     } catch (...) {
34394       {
34395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34396       };
34397     }
34398   }
34399   jresult = result;
34400   return jresult;
34401 }
34402
34403
34404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34405   unsigned int jresult ;
34406   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34407   Dali::HoverEvent *arg2 = 0 ;
34408   bool result;
34409
34410   arg1 = (Dali::CustomActorImpl *)jarg1;
34411   arg2 = (Dali::HoverEvent *)jarg2;
34412   if (!arg2) {
34413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34414     return 0;
34415   }
34416   {
34417     try {
34418       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34419     } catch (std::out_of_range& e) {
34420       {
34421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34422       };
34423     } catch (std::exception& e) {
34424       {
34425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34426       };
34427     } catch (...) {
34428       {
34429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34430       };
34431     }
34432   }
34433   jresult = result;
34434   return jresult;
34435 }
34436
34437
34438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34439   unsigned int jresult ;
34440   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34441   Dali::KeyEvent *arg2 = 0 ;
34442   bool result;
34443
34444   arg1 = (Dali::CustomActorImpl *)jarg1;
34445   arg2 = (Dali::KeyEvent *)jarg2;
34446   if (!arg2) {
34447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34448     return 0;
34449   }
34450   {
34451     try {
34452       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34453     } catch (std::out_of_range& e) {
34454       {
34455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34456       };
34457     } catch (std::exception& e) {
34458       {
34459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34460       };
34461     } catch (...) {
34462       {
34463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34464       };
34465     }
34466   }
34467   jresult = result;
34468   return jresult;
34469 }
34470
34471
34472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34473   unsigned int jresult ;
34474   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34475   Dali::WheelEvent *arg2 = 0 ;
34476   bool result;
34477
34478   arg1 = (Dali::CustomActorImpl *)jarg1;
34479   arg2 = (Dali::WheelEvent *)jarg2;
34480   if (!arg2) {
34481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34482     return 0;
34483   }
34484   {
34485     try {
34486       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34487     } catch (std::out_of_range& e) {
34488       {
34489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34490       };
34491     } catch (std::exception& e) {
34492       {
34493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34494       };
34495     } catch (...) {
34496       {
34497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34498       };
34499     }
34500   }
34501   jresult = result;
34502   return jresult;
34503 }
34504
34505
34506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34507   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34508   Dali::Vector2 *arg2 = 0 ;
34509   Dali::RelayoutContainer *arg3 = 0 ;
34510
34511   arg1 = (Dali::CustomActorImpl *)jarg1;
34512   arg2 = (Dali::Vector2 *)jarg2;
34513   if (!arg2) {
34514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34515     return ;
34516   }
34517   arg3 = (Dali::RelayoutContainer *)jarg3;
34518   if (!arg3) {
34519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34520     return ;
34521   }
34522   {
34523     try {
34524       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34525     } catch (std::out_of_range& e) {
34526       {
34527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34528       };
34529     } catch (std::exception& e) {
34530       {
34531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34532       };
34533     } catch (...) {
34534       {
34535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34536       };
34537     }
34538   }
34539 }
34540
34541
34542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34543   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34544   Dali::ResizePolicy::Type arg2 ;
34545   Dali::Dimension::Type arg3 ;
34546
34547   arg1 = (Dali::CustomActorImpl *)jarg1;
34548   arg2 = (Dali::ResizePolicy::Type)jarg2;
34549   arg3 = (Dali::Dimension::Type)jarg3;
34550   {
34551     try {
34552       (arg1)->OnSetResizePolicy(arg2,arg3);
34553     } catch (std::out_of_range& e) {
34554       {
34555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34556       };
34557     } catch (std::exception& e) {
34558       {
34559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34560       };
34561     } catch (...) {
34562       {
34563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34564       };
34565     }
34566   }
34567 }
34568
34569
34570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34571   void * jresult ;
34572   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34573   Dali::Vector3 result;
34574
34575   arg1 = (Dali::CustomActorImpl *)jarg1;
34576   {
34577     try {
34578       result = (arg1)->GetNaturalSize();
34579     } catch (std::out_of_range& e) {
34580       {
34581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34582       };
34583     } catch (std::exception& e) {
34584       {
34585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34586       };
34587     } catch (...) {
34588       {
34589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34590       };
34591     }
34592   }
34593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34594   return jresult;
34595 }
34596
34597
34598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34599   float jresult ;
34600   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34601   Dali::Actor *arg2 = 0 ;
34602   Dali::Dimension::Type arg3 ;
34603   float result;
34604
34605   arg1 = (Dali::CustomActorImpl *)jarg1;
34606   arg2 = (Dali::Actor *)jarg2;
34607   if (!arg2) {
34608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34609     return 0;
34610   }
34611   arg3 = (Dali::Dimension::Type)jarg3;
34612   {
34613     try {
34614       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34615     } catch (std::out_of_range& e) {
34616       {
34617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34618       };
34619     } catch (std::exception& e) {
34620       {
34621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34622       };
34623     } catch (...) {
34624       {
34625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34626       };
34627     }
34628   }
34629   jresult = result;
34630   return jresult;
34631 }
34632
34633
34634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34635   float jresult ;
34636   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34637   float arg2 ;
34638   float result;
34639
34640   arg1 = (Dali::CustomActorImpl *)jarg1;
34641   arg2 = (float)jarg2;
34642   {
34643     try {
34644       result = (float)(arg1)->GetHeightForWidth(arg2);
34645     } catch (std::out_of_range& e) {
34646       {
34647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34648       };
34649     } catch (std::exception& e) {
34650       {
34651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34652       };
34653     } catch (...) {
34654       {
34655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34656       };
34657     }
34658   }
34659   jresult = result;
34660   return jresult;
34661 }
34662
34663
34664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34665   float jresult ;
34666   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34667   float arg2 ;
34668   float result;
34669
34670   arg1 = (Dali::CustomActorImpl *)jarg1;
34671   arg2 = (float)jarg2;
34672   {
34673     try {
34674       result = (float)(arg1)->GetWidthForHeight(arg2);
34675     } catch (std::out_of_range& e) {
34676       {
34677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34678       };
34679     } catch (std::exception& e) {
34680       {
34681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34682       };
34683     } catch (...) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34686       };
34687     }
34688   }
34689   jresult = result;
34690   return jresult;
34691 }
34692
34693
34694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34695   unsigned int jresult ;
34696   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34697   Dali::Dimension::Type arg2 ;
34698   bool result;
34699
34700   arg1 = (Dali::CustomActorImpl *)jarg1;
34701   arg2 = (Dali::Dimension::Type)jarg2;
34702   {
34703     try {
34704       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34705     } catch (std::out_of_range& e) {
34706       {
34707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34708       };
34709     } catch (std::exception& e) {
34710       {
34711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34712       };
34713     } catch (...) {
34714       {
34715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34716       };
34717     }
34718   }
34719   jresult = result;
34720   return jresult;
34721 }
34722
34723
34724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34725   unsigned int jresult ;
34726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34727   bool result;
34728
34729   arg1 = (Dali::CustomActorImpl *)jarg1;
34730   {
34731     try {
34732       result = (bool)(arg1)->RelayoutDependentOnChildren();
34733     } catch (std::out_of_range& e) {
34734       {
34735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34736       };
34737     } catch (std::exception& e) {
34738       {
34739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34740       };
34741     } catch (...) {
34742       {
34743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34744       };
34745     }
34746   }
34747   jresult = result;
34748   return jresult;
34749 }
34750
34751
34752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34753   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34754   Dali::Dimension::Type arg2 ;
34755
34756   arg1 = (Dali::CustomActorImpl *)jarg1;
34757   arg2 = (Dali::Dimension::Type)jarg2;
34758   {
34759     try {
34760       (arg1)->OnCalculateRelayoutSize(arg2);
34761     } catch (std::out_of_range& e) {
34762       {
34763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34764       };
34765     } catch (std::exception& e) {
34766       {
34767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34768       };
34769     } catch (...) {
34770       {
34771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34772       };
34773     }
34774   }
34775 }
34776
34777
34778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34779   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34780   float arg2 ;
34781   Dali::Dimension::Type arg3 ;
34782
34783   arg1 = (Dali::CustomActorImpl *)jarg1;
34784   arg2 = (float)jarg2;
34785   arg3 = (Dali::Dimension::Type)jarg3;
34786   {
34787     try {
34788       (arg1)->OnLayoutNegotiated(arg2,arg3);
34789     } catch (std::out_of_range& e) {
34790       {
34791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34792       };
34793     } catch (std::exception& e) {
34794       {
34795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34796       };
34797     } catch (...) {
34798       {
34799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34800       };
34801     }
34802   }
34803 }
34804
34805
34806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34807   unsigned int jresult ;
34808   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34809   bool result;
34810
34811   arg1 = (Dali::CustomActorImpl *)jarg1;
34812   {
34813     try {
34814       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34815     } catch (std::out_of_range& e) {
34816       {
34817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34818       };
34819     } catch (std::exception& e) {
34820       {
34821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34822       };
34823     } catch (...) {
34824       {
34825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34826       };
34827     }
34828   }
34829   jresult = result;
34830   return jresult;
34831 }
34832
34833
34834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34835   unsigned int jresult ;
34836   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34837   bool result;
34838
34839   arg1 = (Dali::CustomActorImpl *)jarg1;
34840   {
34841     try {
34842       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34843     } catch (std::out_of_range& e) {
34844       {
34845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34846       };
34847     } catch (std::exception& e) {
34848       {
34849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34850       };
34851     } catch (...) {
34852       {
34853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34854       };
34855     }
34856   }
34857   jresult = result;
34858   return jresult;
34859 }
34860
34861
34862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34863   unsigned int jresult ;
34864   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34865   bool result;
34866
34867   arg1 = (Dali::CustomActorImpl *)jarg1;
34868   {
34869     try {
34870       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34871     } catch (std::out_of_range& e) {
34872       {
34873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34874       };
34875     } catch (std::exception& e) {
34876       {
34877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34878       };
34879     } catch (...) {
34880       {
34881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34882       };
34883     }
34884   }
34885   jresult = result;
34886   return jresult;
34887 }
34888
34889
34890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34891   unsigned int jresult ;
34892   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34893   bool result;
34894
34895   arg1 = (Dali::CustomActorImpl *)jarg1;
34896   {
34897     try {
34898       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34899     } catch (std::out_of_range& e) {
34900       {
34901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34902       };
34903     } catch (std::exception& e) {
34904       {
34905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34906       };
34907     } catch (...) {
34908       {
34909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34910       };
34911     }
34912   }
34913   jresult = result;
34914   return jresult;
34915 }
34916
34917
34918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34919   void * jresult ;
34920   Dali::CustomActor *result = 0 ;
34921
34922   {
34923     try {
34924       result = (Dali::CustomActor *)new Dali::CustomActor();
34925     } catch (std::out_of_range& e) {
34926       {
34927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34928       };
34929     } catch (std::exception& e) {
34930       {
34931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34932       };
34933     } catch (...) {
34934       {
34935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34936       };
34937     }
34938   }
34939   jresult = (void *)result;
34940   return jresult;
34941 }
34942
34943
34944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34945   void * jresult ;
34946   Dali::BaseHandle arg1 ;
34947   Dali::BaseHandle *argp1 ;
34948   Dali::CustomActor result;
34949
34950   argp1 = (Dali::BaseHandle *)jarg1;
34951   if (!argp1) {
34952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34953     return 0;
34954   }
34955   arg1 = *argp1;
34956   {
34957     try {
34958       result = Dali::CustomActor::DownCast(arg1);
34959     } catch (std::out_of_range& e) {
34960       {
34961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34962       };
34963     } catch (std::exception& e) {
34964       {
34965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34966       };
34967     } catch (...) {
34968       {
34969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34970       };
34971     }
34972   }
34973   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34974   return jresult;
34975 }
34976
34977
34978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34979   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34980
34981   arg1 = (Dali::CustomActor *)jarg1;
34982   {
34983     try {
34984       delete arg1;
34985     } catch (std::out_of_range& e) {
34986       {
34987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34988       };
34989     } catch (std::exception& e) {
34990       {
34991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34992       };
34993     } catch (...) {
34994       {
34995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34996       };
34997     }
34998   }
34999 }
35000
35001
35002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35003   void * jresult ;
35004   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35005   Dali::CustomActorImpl *result = 0 ;
35006
35007   arg1 = (Dali::CustomActor *)jarg1;
35008   {
35009     try {
35010       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35011     } catch (std::out_of_range& e) {
35012       {
35013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35014       };
35015     } catch (std::exception& e) {
35016       {
35017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35018       };
35019     } catch (...) {
35020       {
35021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35022       };
35023     }
35024   }
35025   jresult = (void *)result;
35026   return jresult;
35027 }
35028
35029
35030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35031   void * jresult ;
35032   Dali::CustomActorImpl *arg1 = 0 ;
35033   Dali::CustomActor *result = 0 ;
35034
35035   arg1 = (Dali::CustomActorImpl *)jarg1;
35036   if (!arg1) {
35037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35038     return 0;
35039   }
35040   {
35041     try {
35042       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35043     } catch (std::out_of_range& e) {
35044       {
35045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35046       };
35047     } catch (std::exception& e) {
35048       {
35049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35050       };
35051     } catch (...) {
35052       {
35053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35054       };
35055     }
35056   }
35057   jresult = (void *)result;
35058   return jresult;
35059 }
35060
35061
35062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35063   void * jresult ;
35064   Dali::CustomActor *arg1 = 0 ;
35065   Dali::CustomActor *result = 0 ;
35066
35067   arg1 = (Dali::CustomActor *)jarg1;
35068   if (!arg1) {
35069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35070     return 0;
35071   }
35072   {
35073     try {
35074       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35075     } catch (std::out_of_range& e) {
35076       {
35077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35078       };
35079     } catch (std::exception& e) {
35080       {
35081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35082       };
35083     } catch (...) {
35084       {
35085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35086       };
35087     }
35088   }
35089   jresult = (void *)result;
35090   return jresult;
35091 }
35092
35093
35094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35095   void * jresult ;
35096   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35097   Dali::CustomActor *arg2 = 0 ;
35098   Dali::CustomActor *result = 0 ;
35099
35100   arg1 = (Dali::CustomActor *)jarg1;
35101   arg2 = (Dali::CustomActor *)jarg2;
35102   if (!arg2) {
35103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35104     return 0;
35105   }
35106   {
35107     try {
35108       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35109     } catch (std::out_of_range& e) {
35110       {
35111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35112       };
35113     } catch (std::exception& e) {
35114       {
35115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35116       };
35117     } catch (...) {
35118       {
35119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35120       };
35121     }
35122   }
35123   jresult = (void *)result;
35124   return jresult;
35125 }
35126
35127
35128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35129   int jresult ;
35130   int result;
35131
35132   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35133   jresult = (int)result;
35134   return jresult;
35135 }
35136
35137
35138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35139   int jresult ;
35140   int result;
35141
35142   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35143   jresult = (int)result;
35144   return jresult;
35145 }
35146
35147
35148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35149   int jresult ;
35150   int result;
35151
35152   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35153   jresult = (int)result;
35154   return jresult;
35155 }
35156
35157
35158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35159   int jresult ;
35160   int result;
35161
35162   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35163   jresult = (int)result;
35164   return jresult;
35165 }
35166
35167
35168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35169   int jresult ;
35170   int result;
35171
35172   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35173   jresult = (int)result;
35174   return jresult;
35175 }
35176
35177
35178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35179   int jresult ;
35180   int result;
35181
35182   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35183   jresult = (int)result;
35184   return jresult;
35185 }
35186
35187
35188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35189   int jresult ;
35190   int result;
35191
35192   result = (int)Dali::PanGestureDetector::Property::PANNING;
35193   jresult = (int)result;
35194   return jresult;
35195 }
35196
35197
35198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35199   void * jresult ;
35200   Dali::PanGestureDetector::Property *result = 0 ;
35201
35202   {
35203     try {
35204       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35205     } catch (std::out_of_range& e) {
35206       {
35207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35208       };
35209     } catch (std::exception& e) {
35210       {
35211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35212       };
35213     } catch (...) {
35214       {
35215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35216       };
35217     }
35218   }
35219   jresult = (void *)result;
35220   return jresult;
35221 }
35222
35223
35224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35225   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35226
35227   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35228   {
35229     try {
35230       delete arg1;
35231     } catch (std::out_of_range& e) {
35232       {
35233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35234       };
35235     } catch (std::exception& e) {
35236       {
35237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35238       };
35239     } catch (...) {
35240       {
35241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35242       };
35243     }
35244   }
35245 }
35246
35247
35248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35249   void * jresult ;
35250   Dali::Radian *result = 0 ;
35251
35252   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35253   jresult = (void *)result;
35254   return jresult;
35255 }
35256
35257
35258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35259   void * jresult ;
35260   Dali::Radian *result = 0 ;
35261
35262   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35263   jresult = (void *)result;
35264   return jresult;
35265 }
35266
35267
35268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35269   void * jresult ;
35270   Dali::Radian *result = 0 ;
35271
35272   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35273   jresult = (void *)result;
35274   return jresult;
35275 }
35276
35277
35278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35279   void * jresult ;
35280   Dali::Radian *result = 0 ;
35281
35282   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35283   jresult = (void *)result;
35284   return jresult;
35285 }
35286
35287
35288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35289   void * jresult ;
35290   Dali::Radian *result = 0 ;
35291
35292   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35293   jresult = (void *)result;
35294   return jresult;
35295 }
35296
35297
35298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35299   void * jresult ;
35300   Dali::Radian *result = 0 ;
35301
35302   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35303   jresult = (void *)result;
35304   return jresult;
35305 }
35306
35307
35308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35309   void * jresult ;
35310   Dali::Radian *result = 0 ;
35311
35312   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35313   jresult = (void *)result;
35314   return jresult;
35315 }
35316
35317
35318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35319   void * jresult ;
35320   Dali::PanGestureDetector *result = 0 ;
35321
35322   {
35323     try {
35324       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35325     } catch (std::out_of_range& e) {
35326       {
35327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35328       };
35329     } catch (std::exception& e) {
35330       {
35331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35332       };
35333     } catch (...) {
35334       {
35335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35336       };
35337     }
35338   }
35339   jresult = (void *)result;
35340   return jresult;
35341 }
35342
35343
35344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35345   void * jresult ;
35346   Dali::PanGestureDetector result;
35347
35348   {
35349     try {
35350       result = Dali::PanGestureDetector::New();
35351     } catch (std::out_of_range& e) {
35352       {
35353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35354       };
35355     } catch (std::exception& e) {
35356       {
35357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35358       };
35359     } catch (...) {
35360       {
35361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35362       };
35363     }
35364   }
35365   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35366   return jresult;
35367 }
35368
35369
35370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35371   void * jresult ;
35372   Dali::BaseHandle arg1 ;
35373   Dali::BaseHandle *argp1 ;
35374   Dali::PanGestureDetector result;
35375
35376   argp1 = (Dali::BaseHandle *)jarg1;
35377   if (!argp1) {
35378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35379     return 0;
35380   }
35381   arg1 = *argp1;
35382   {
35383     try {
35384       result = Dali::PanGestureDetector::DownCast(arg1);
35385     } catch (std::out_of_range& e) {
35386       {
35387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35388       };
35389     } catch (std::exception& e) {
35390       {
35391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35392       };
35393     } catch (...) {
35394       {
35395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35396       };
35397     }
35398   }
35399   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35400   return jresult;
35401 }
35402
35403
35404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35405   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35406
35407   arg1 = (Dali::PanGestureDetector *)jarg1;
35408   {
35409     try {
35410       delete arg1;
35411     } catch (std::out_of_range& e) {
35412       {
35413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35414       };
35415     } catch (std::exception& e) {
35416       {
35417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35418       };
35419     } catch (...) {
35420       {
35421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35422       };
35423     }
35424   }
35425 }
35426
35427
35428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35429   void * jresult ;
35430   Dali::PanGestureDetector *arg1 = 0 ;
35431   Dali::PanGestureDetector *result = 0 ;
35432
35433   arg1 = (Dali::PanGestureDetector *)jarg1;
35434   if (!arg1) {
35435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35436     return 0;
35437   }
35438   {
35439     try {
35440       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35441     } catch (std::out_of_range& e) {
35442       {
35443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35444       };
35445     } catch (std::exception& e) {
35446       {
35447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35448       };
35449     } catch (...) {
35450       {
35451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35452       };
35453     }
35454   }
35455   jresult = (void *)result;
35456   return jresult;
35457 }
35458
35459
35460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35461   void * jresult ;
35462   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35463   Dali::PanGestureDetector *arg2 = 0 ;
35464   Dali::PanGestureDetector *result = 0 ;
35465
35466   arg1 = (Dali::PanGestureDetector *)jarg1;
35467   arg2 = (Dali::PanGestureDetector *)jarg2;
35468   if (!arg2) {
35469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35470     return 0;
35471   }
35472   {
35473     try {
35474       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35475     } catch (std::out_of_range& e) {
35476       {
35477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35478       };
35479     } catch (std::exception& e) {
35480       {
35481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35482       };
35483     } catch (...) {
35484       {
35485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35486       };
35487     }
35488   }
35489   jresult = (void *)result;
35490   return jresult;
35491 }
35492
35493
35494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35495   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35496   unsigned int arg2 ;
35497
35498   arg1 = (Dali::PanGestureDetector *)jarg1;
35499   arg2 = (unsigned int)jarg2;
35500   {
35501     try {
35502       (arg1)->SetMinimumTouchesRequired(arg2);
35503     } catch (std::out_of_range& e) {
35504       {
35505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35506       };
35507     } catch (std::exception& e) {
35508       {
35509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35510       };
35511     } catch (...) {
35512       {
35513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35514       };
35515     }
35516   }
35517 }
35518
35519
35520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35521   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35522   unsigned int arg2 ;
35523
35524   arg1 = (Dali::PanGestureDetector *)jarg1;
35525   arg2 = (unsigned int)jarg2;
35526   {
35527     try {
35528       (arg1)->SetMaximumTouchesRequired(arg2);
35529     } catch (std::out_of_range& e) {
35530       {
35531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35532       };
35533     } catch (std::exception& e) {
35534       {
35535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35536       };
35537     } catch (...) {
35538       {
35539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35540       };
35541     }
35542   }
35543 }
35544
35545
35546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35547   unsigned int jresult ;
35548   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35549   unsigned int result;
35550
35551   arg1 = (Dali::PanGestureDetector *)jarg1;
35552   {
35553     try {
35554       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35555     } catch (std::out_of_range& e) {
35556       {
35557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35558       };
35559     } catch (std::exception& e) {
35560       {
35561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35562       };
35563     } catch (...) {
35564       {
35565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35566       };
35567     }
35568   }
35569   jresult = result;
35570   return jresult;
35571 }
35572
35573
35574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35575   unsigned int jresult ;
35576   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35577   unsigned int result;
35578
35579   arg1 = (Dali::PanGestureDetector *)jarg1;
35580   {
35581     try {
35582       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35583     } catch (std::out_of_range& e) {
35584       {
35585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35586       };
35587     } catch (std::exception& e) {
35588       {
35589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35590       };
35591     } catch (...) {
35592       {
35593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35594       };
35595     }
35596   }
35597   jresult = result;
35598   return jresult;
35599 }
35600
35601
35602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35603   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35604   Dali::Radian arg2 ;
35605   Dali::Radian arg3 ;
35606   Dali::Radian *argp2 ;
35607   Dali::Radian *argp3 ;
35608
35609   arg1 = (Dali::PanGestureDetector *)jarg1;
35610   argp2 = (Dali::Radian *)jarg2;
35611   if (!argp2) {
35612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35613     return ;
35614   }
35615   arg2 = *argp2;
35616   argp3 = (Dali::Radian *)jarg3;
35617   if (!argp3) {
35618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35619     return ;
35620   }
35621   arg3 = *argp3;
35622   {
35623     try {
35624       (arg1)->AddAngle(arg2,arg3);
35625     } catch (std::out_of_range& e) {
35626       {
35627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35628       };
35629     } catch (std::exception& e) {
35630       {
35631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35632       };
35633     } catch (...) {
35634       {
35635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35636       };
35637     }
35638   }
35639 }
35640
35641
35642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35643   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35644   Dali::Radian arg2 ;
35645   Dali::Radian *argp2 ;
35646
35647   arg1 = (Dali::PanGestureDetector *)jarg1;
35648   argp2 = (Dali::Radian *)jarg2;
35649   if (!argp2) {
35650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35651     return ;
35652   }
35653   arg2 = *argp2;
35654   {
35655     try {
35656       (arg1)->AddAngle(arg2);
35657     } catch (std::out_of_range& e) {
35658       {
35659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35660       };
35661     } catch (std::exception& e) {
35662       {
35663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35664       };
35665     } catch (...) {
35666       {
35667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35668       };
35669     }
35670   }
35671 }
35672
35673
35674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35675   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35676   Dali::Radian arg2 ;
35677   Dali::Radian arg3 ;
35678   Dali::Radian *argp2 ;
35679   Dali::Radian *argp3 ;
35680
35681   arg1 = (Dali::PanGestureDetector *)jarg1;
35682   argp2 = (Dali::Radian *)jarg2;
35683   if (!argp2) {
35684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35685     return ;
35686   }
35687   arg2 = *argp2;
35688   argp3 = (Dali::Radian *)jarg3;
35689   if (!argp3) {
35690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35691     return ;
35692   }
35693   arg3 = *argp3;
35694   {
35695     try {
35696       (arg1)->AddDirection(arg2,arg3);
35697     } catch (std::out_of_range& e) {
35698       {
35699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35700       };
35701     } catch (std::exception& e) {
35702       {
35703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35704       };
35705     } catch (...) {
35706       {
35707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35708       };
35709     }
35710   }
35711 }
35712
35713
35714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35715   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35716   Dali::Radian arg2 ;
35717   Dali::Radian *argp2 ;
35718
35719   arg1 = (Dali::PanGestureDetector *)jarg1;
35720   argp2 = (Dali::Radian *)jarg2;
35721   if (!argp2) {
35722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35723     return ;
35724   }
35725   arg2 = *argp2;
35726   {
35727     try {
35728       (arg1)->AddDirection(arg2);
35729     } catch (std::out_of_range& e) {
35730       {
35731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35732       };
35733     } catch (std::exception& e) {
35734       {
35735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35736       };
35737     } catch (...) {
35738       {
35739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35740       };
35741     }
35742   }
35743 }
35744
35745
35746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35747   unsigned long jresult ;
35748   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35749   size_t result;
35750
35751   arg1 = (Dali::PanGestureDetector *)jarg1;
35752   {
35753     try {
35754       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35755     } catch (std::out_of_range& e) {
35756       {
35757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35758       };
35759     } catch (std::exception& e) {
35760       {
35761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35762       };
35763     } catch (...) {
35764       {
35765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35766       };
35767     }
35768   }
35769   jresult = (unsigned long)result;
35770   return jresult;
35771 }
35772
35773
35774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35775   void * jresult ;
35776   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35777   size_t arg2 ;
35778   Dali::PanGestureDetector::AngleThresholdPair result;
35779
35780   arg1 = (Dali::PanGestureDetector *)jarg1;
35781   arg2 = (size_t)jarg2;
35782   {
35783     try {
35784       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35785     } catch (std::out_of_range& e) {
35786       {
35787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35788       };
35789     } catch (std::exception& e) {
35790       {
35791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35792       };
35793     } catch (...) {
35794       {
35795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35796       };
35797     }
35798   }
35799   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35800   return jresult;
35801 }
35802
35803
35804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35805   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35806
35807   arg1 = (Dali::PanGestureDetector *)jarg1;
35808   {
35809     try {
35810       (arg1)->ClearAngles();
35811     } catch (std::out_of_range& e) {
35812       {
35813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35814       };
35815     } catch (std::exception& e) {
35816       {
35817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35818       };
35819     } catch (...) {
35820       {
35821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35822       };
35823     }
35824   }
35825 }
35826
35827
35828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35829   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35830   Dali::Radian arg2 ;
35831   Dali::Radian *argp2 ;
35832
35833   arg1 = (Dali::PanGestureDetector *)jarg1;
35834   argp2 = (Dali::Radian *)jarg2;
35835   if (!argp2) {
35836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35837     return ;
35838   }
35839   arg2 = *argp2;
35840   {
35841     try {
35842       (arg1)->RemoveAngle(arg2);
35843     } catch (std::out_of_range& e) {
35844       {
35845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35846       };
35847     } catch (std::exception& e) {
35848       {
35849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35850       };
35851     } catch (...) {
35852       {
35853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35854       };
35855     }
35856   }
35857 }
35858
35859
35860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35861   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35862   Dali::Radian arg2 ;
35863   Dali::Radian *argp2 ;
35864
35865   arg1 = (Dali::PanGestureDetector *)jarg1;
35866   argp2 = (Dali::Radian *)jarg2;
35867   if (!argp2) {
35868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35869     return ;
35870   }
35871   arg2 = *argp2;
35872   {
35873     try {
35874       (arg1)->RemoveDirection(arg2);
35875     } catch (std::out_of_range& e) {
35876       {
35877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35878       };
35879     } catch (std::exception& e) {
35880       {
35881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35882       };
35883     } catch (...) {
35884       {
35885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35886       };
35887     }
35888   }
35889 }
35890
35891
35892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35893   void * jresult ;
35894   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35895   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35896
35897   arg1 = (Dali::PanGestureDetector *)jarg1;
35898   {
35899     try {
35900       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35901     } catch (std::out_of_range& e) {
35902       {
35903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35904       };
35905     } catch (std::exception& e) {
35906       {
35907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35908       };
35909     } catch (...) {
35910       {
35911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35912       };
35913     }
35914   }
35915   jresult = (void *)result;
35916   return jresult;
35917 }
35918
35919
35920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35921   Dali::PanGesture *arg1 = 0 ;
35922
35923   arg1 = (Dali::PanGesture *)jarg1;
35924   if (!arg1) {
35925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35926     return ;
35927   }
35928   {
35929     try {
35930       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35931     } catch (std::out_of_range& e) {
35932       {
35933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35934       };
35935     } catch (std::exception& e) {
35936       {
35937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35938       };
35939     } catch (...) {
35940       {
35941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35942       };
35943     }
35944   }
35945 }
35946
35947
35948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35949   void * jresult ;
35950   Dali::PanGesture *result = 0 ;
35951
35952   {
35953     try {
35954       result = (Dali::PanGesture *)new Dali::PanGesture();
35955     } catch (std::out_of_range& e) {
35956       {
35957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35958       };
35959     } catch (std::exception& e) {
35960       {
35961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35962       };
35963     } catch (...) {
35964       {
35965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35966       };
35967     }
35968   }
35969   jresult = (void *)result;
35970   return jresult;
35971 }
35972
35973
35974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35975   void * jresult ;
35976   Dali::Gesture::State arg1 ;
35977   Dali::PanGesture *result = 0 ;
35978
35979   arg1 = (Dali::Gesture::State)jarg1;
35980   {
35981     try {
35982       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35983     } catch (std::out_of_range& e) {
35984       {
35985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35986       };
35987     } catch (std::exception& e) {
35988       {
35989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35990       };
35991     } catch (...) {
35992       {
35993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35994       };
35995     }
35996   }
35997   jresult = (void *)result;
35998   return jresult;
35999 }
36000
36001
36002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36003   void * jresult ;
36004   Dali::PanGesture *arg1 = 0 ;
36005   Dali::PanGesture *result = 0 ;
36006
36007   arg1 = (Dali::PanGesture *)jarg1;
36008   if (!arg1) {
36009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36010     return 0;
36011   }
36012   {
36013     try {
36014       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36015     } catch (std::out_of_range& e) {
36016       {
36017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36018       };
36019     } catch (std::exception& e) {
36020       {
36021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36022       };
36023     } catch (...) {
36024       {
36025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36026       };
36027     }
36028   }
36029   jresult = (void *)result;
36030   return jresult;
36031 }
36032
36033
36034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36035   void * jresult ;
36036   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36037   Dali::PanGesture *arg2 = 0 ;
36038   Dali::PanGesture *result = 0 ;
36039
36040   arg1 = (Dali::PanGesture *)jarg1;
36041   arg2 = (Dali::PanGesture *)jarg2;
36042   if (!arg2) {
36043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36044     return 0;
36045   }
36046   {
36047     try {
36048       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36049     } catch (std::out_of_range& e) {
36050       {
36051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36052       };
36053     } catch (std::exception& e) {
36054       {
36055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36056       };
36057     } catch (...) {
36058       {
36059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36060       };
36061     }
36062   }
36063   jresult = (void *)result;
36064   return jresult;
36065 }
36066
36067
36068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36069   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36070
36071   arg1 = (Dali::PanGesture *)jarg1;
36072   {
36073     try {
36074       delete arg1;
36075     } catch (std::out_of_range& e) {
36076       {
36077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36078       };
36079     } catch (std::exception& e) {
36080       {
36081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36082       };
36083     } catch (...) {
36084       {
36085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36086       };
36087     }
36088   }
36089 }
36090
36091
36092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36093   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36094   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36095
36096   arg1 = (Dali::PanGesture *)jarg1;
36097   arg2 = (Dali::Vector2 *)jarg2;
36098   if (arg1) (arg1)->velocity = *arg2;
36099 }
36100
36101
36102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36103   void * jresult ;
36104   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36105   Dali::Vector2 *result = 0 ;
36106
36107   arg1 = (Dali::PanGesture *)jarg1;
36108   result = (Dali::Vector2 *)& ((arg1)->velocity);
36109   jresult = (void *)result;
36110   return jresult;
36111 }
36112
36113
36114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36115   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36116   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36117
36118   arg1 = (Dali::PanGesture *)jarg1;
36119   arg2 = (Dali::Vector2 *)jarg2;
36120   if (arg1) (arg1)->displacement = *arg2;
36121 }
36122
36123
36124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36125   void * jresult ;
36126   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36127   Dali::Vector2 *result = 0 ;
36128
36129   arg1 = (Dali::PanGesture *)jarg1;
36130   result = (Dali::Vector2 *)& ((arg1)->displacement);
36131   jresult = (void *)result;
36132   return jresult;
36133 }
36134
36135
36136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36137   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36138   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36139
36140   arg1 = (Dali::PanGesture *)jarg1;
36141   arg2 = (Dali::Vector2 *)jarg2;
36142   if (arg1) (arg1)->position = *arg2;
36143 }
36144
36145
36146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36147   void * jresult ;
36148   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36149   Dali::Vector2 *result = 0 ;
36150
36151   arg1 = (Dali::PanGesture *)jarg1;
36152   result = (Dali::Vector2 *)& ((arg1)->position);
36153   jresult = (void *)result;
36154   return jresult;
36155 }
36156
36157
36158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36159   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36160   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36161
36162   arg1 = (Dali::PanGesture *)jarg1;
36163   arg2 = (Dali::Vector2 *)jarg2;
36164   if (arg1) (arg1)->screenVelocity = *arg2;
36165 }
36166
36167
36168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36169   void * jresult ;
36170   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36171   Dali::Vector2 *result = 0 ;
36172
36173   arg1 = (Dali::PanGesture *)jarg1;
36174   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36175   jresult = (void *)result;
36176   return jresult;
36177 }
36178
36179
36180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36181   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36182   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36183
36184   arg1 = (Dali::PanGesture *)jarg1;
36185   arg2 = (Dali::Vector2 *)jarg2;
36186   if (arg1) (arg1)->screenDisplacement = *arg2;
36187 }
36188
36189
36190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36191   void * jresult ;
36192   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36193   Dali::Vector2 *result = 0 ;
36194
36195   arg1 = (Dali::PanGesture *)jarg1;
36196   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36197   jresult = (void *)result;
36198   return jresult;
36199 }
36200
36201
36202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36203   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36204   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36205
36206   arg1 = (Dali::PanGesture *)jarg1;
36207   arg2 = (Dali::Vector2 *)jarg2;
36208   if (arg1) (arg1)->screenPosition = *arg2;
36209 }
36210
36211
36212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36213   void * jresult ;
36214   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36215   Dali::Vector2 *result = 0 ;
36216
36217   arg1 = (Dali::PanGesture *)jarg1;
36218   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36219   jresult = (void *)result;
36220   return jresult;
36221 }
36222
36223
36224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36225   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36226   unsigned int arg2 ;
36227
36228   arg1 = (Dali::PanGesture *)jarg1;
36229   arg2 = (unsigned int)jarg2;
36230   if (arg1) (arg1)->numberOfTouches = arg2;
36231 }
36232
36233
36234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36235   unsigned int jresult ;
36236   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36237   unsigned int result;
36238
36239   arg1 = (Dali::PanGesture *)jarg1;
36240   result = (unsigned int) ((arg1)->numberOfTouches);
36241   jresult = result;
36242   return jresult;
36243 }
36244
36245
36246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36247   float jresult ;
36248   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36249   float result;
36250
36251   arg1 = (Dali::PanGesture *)jarg1;
36252   {
36253     try {
36254       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36255     } catch (std::out_of_range& e) {
36256       {
36257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36258       };
36259     } catch (std::exception& e) {
36260       {
36261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36262       };
36263     } catch (...) {
36264       {
36265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36266       };
36267     }
36268   }
36269   jresult = result;
36270   return jresult;
36271 }
36272
36273
36274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36275   float jresult ;
36276   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36277   float result;
36278
36279   arg1 = (Dali::PanGesture *)jarg1;
36280   {
36281     try {
36282       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36283     } catch (std::out_of_range& e) {
36284       {
36285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36286       };
36287     } catch (std::exception& e) {
36288       {
36289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36290       };
36291     } catch (...) {
36292       {
36293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36294       };
36295     }
36296   }
36297   jresult = result;
36298   return jresult;
36299 }
36300
36301
36302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36303   float jresult ;
36304   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36305   float result;
36306
36307   arg1 = (Dali::PanGesture *)jarg1;
36308   {
36309     try {
36310       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36311     } catch (std::out_of_range& e) {
36312       {
36313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36314       };
36315     } catch (std::exception& e) {
36316       {
36317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36318       };
36319     } catch (...) {
36320       {
36321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36322       };
36323     }
36324   }
36325   jresult = result;
36326   return jresult;
36327 }
36328
36329
36330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36331   float jresult ;
36332   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36333   float result;
36334
36335   arg1 = (Dali::PanGesture *)jarg1;
36336   {
36337     try {
36338       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36339     } catch (std::out_of_range& e) {
36340       {
36341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36342       };
36343     } catch (std::exception& e) {
36344       {
36345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36346       };
36347     } catch (...) {
36348       {
36349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36350       };
36351     }
36352   }
36353   jresult = result;
36354   return jresult;
36355 }
36356
36357
36358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36359   void * jresult ;
36360   Dali::PinchGestureDetector *result = 0 ;
36361
36362   {
36363     try {
36364       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36365     } catch (std::out_of_range& e) {
36366       {
36367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36368       };
36369     } catch (std::exception& e) {
36370       {
36371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36372       };
36373     } catch (...) {
36374       {
36375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36376       };
36377     }
36378   }
36379   jresult = (void *)result;
36380   return jresult;
36381 }
36382
36383
36384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36385   void * jresult ;
36386   Dali::PinchGestureDetector result;
36387
36388   {
36389     try {
36390       result = Dali::PinchGestureDetector::New();
36391     } catch (std::out_of_range& e) {
36392       {
36393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36394       };
36395     } catch (std::exception& e) {
36396       {
36397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36398       };
36399     } catch (...) {
36400       {
36401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36402       };
36403     }
36404   }
36405   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36406   return jresult;
36407 }
36408
36409
36410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36411   void * jresult ;
36412   Dali::BaseHandle arg1 ;
36413   Dali::BaseHandle *argp1 ;
36414   Dali::PinchGestureDetector result;
36415
36416   argp1 = (Dali::BaseHandle *)jarg1;
36417   if (!argp1) {
36418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36419     return 0;
36420   }
36421   arg1 = *argp1;
36422   {
36423     try {
36424       result = Dali::PinchGestureDetector::DownCast(arg1);
36425     } catch (std::out_of_range& e) {
36426       {
36427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36428       };
36429     } catch (std::exception& e) {
36430       {
36431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36432       };
36433     } catch (...) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36436       };
36437     }
36438   }
36439   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36440   return jresult;
36441 }
36442
36443
36444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36445   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36446
36447   arg1 = (Dali::PinchGestureDetector *)jarg1;
36448   {
36449     try {
36450       delete arg1;
36451     } catch (std::out_of_range& e) {
36452       {
36453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36454       };
36455     } catch (std::exception& e) {
36456       {
36457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36458       };
36459     } catch (...) {
36460       {
36461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36462       };
36463     }
36464   }
36465 }
36466
36467
36468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36469   void * jresult ;
36470   Dali::PinchGestureDetector *arg1 = 0 ;
36471   Dali::PinchGestureDetector *result = 0 ;
36472
36473   arg1 = (Dali::PinchGestureDetector *)jarg1;
36474   if (!arg1) {
36475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36476     return 0;
36477   }
36478   {
36479     try {
36480       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36481     } catch (std::out_of_range& e) {
36482       {
36483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36484       };
36485     } catch (std::exception& e) {
36486       {
36487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36488       };
36489     } catch (...) {
36490       {
36491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36492       };
36493     }
36494   }
36495   jresult = (void *)result;
36496   return jresult;
36497 }
36498
36499
36500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36501   void * jresult ;
36502   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36503   Dali::PinchGestureDetector *arg2 = 0 ;
36504   Dali::PinchGestureDetector *result = 0 ;
36505
36506   arg1 = (Dali::PinchGestureDetector *)jarg1;
36507   arg2 = (Dali::PinchGestureDetector *)jarg2;
36508   if (!arg2) {
36509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36510     return 0;
36511   }
36512   {
36513     try {
36514       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36515     } catch (std::out_of_range& e) {
36516       {
36517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36518       };
36519     } catch (std::exception& e) {
36520       {
36521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36522       };
36523     } catch (...) {
36524       {
36525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36526       };
36527     }
36528   }
36529   jresult = (void *)result;
36530   return jresult;
36531 }
36532
36533
36534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36535   void * jresult ;
36536   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36537   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36538
36539   arg1 = (Dali::PinchGestureDetector *)jarg1;
36540   {
36541     try {
36542       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36543     } catch (std::out_of_range& e) {
36544       {
36545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36546       };
36547     } catch (std::exception& e) {
36548       {
36549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36550       };
36551     } catch (...) {
36552       {
36553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36554       };
36555     }
36556   }
36557   jresult = (void *)result;
36558   return jresult;
36559 }
36560
36561
36562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36563   void * jresult ;
36564   Dali::Gesture::State arg1 ;
36565   Dali::PinchGesture *result = 0 ;
36566
36567   arg1 = (Dali::Gesture::State)jarg1;
36568   {
36569     try {
36570       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36571     } catch (std::out_of_range& e) {
36572       {
36573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36574       };
36575     } catch (std::exception& e) {
36576       {
36577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36578       };
36579     } catch (...) {
36580       {
36581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36582       };
36583     }
36584   }
36585   jresult = (void *)result;
36586   return jresult;
36587 }
36588
36589
36590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36591   void * jresult ;
36592   Dali::PinchGesture *arg1 = 0 ;
36593   Dali::PinchGesture *result = 0 ;
36594
36595   arg1 = (Dali::PinchGesture *)jarg1;
36596   if (!arg1) {
36597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36598     return 0;
36599   }
36600   {
36601     try {
36602       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36603     } catch (std::out_of_range& e) {
36604       {
36605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36606       };
36607     } catch (std::exception& e) {
36608       {
36609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36610       };
36611     } catch (...) {
36612       {
36613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36614       };
36615     }
36616   }
36617   jresult = (void *)result;
36618   return jresult;
36619 }
36620
36621
36622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36623   void * jresult ;
36624   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36625   Dali::PinchGesture *arg2 = 0 ;
36626   Dali::PinchGesture *result = 0 ;
36627
36628   arg1 = (Dali::PinchGesture *)jarg1;
36629   arg2 = (Dali::PinchGesture *)jarg2;
36630   if (!arg2) {
36631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36632     return 0;
36633   }
36634   {
36635     try {
36636       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36637     } catch (std::out_of_range& e) {
36638       {
36639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36640       };
36641     } catch (std::exception& e) {
36642       {
36643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36644       };
36645     } catch (...) {
36646       {
36647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36648       };
36649     }
36650   }
36651   jresult = (void *)result;
36652   return jresult;
36653 }
36654
36655
36656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36657   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36658
36659   arg1 = (Dali::PinchGesture *)jarg1;
36660   {
36661     try {
36662       delete arg1;
36663     } catch (std::out_of_range& e) {
36664       {
36665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36666       };
36667     } catch (std::exception& e) {
36668       {
36669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36670       };
36671     } catch (...) {
36672       {
36673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36674       };
36675     }
36676   }
36677 }
36678
36679
36680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36681   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36682   float arg2 ;
36683
36684   arg1 = (Dali::PinchGesture *)jarg1;
36685   arg2 = (float)jarg2;
36686   if (arg1) (arg1)->scale = arg2;
36687 }
36688
36689
36690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36691   float jresult ;
36692   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36693   float result;
36694
36695   arg1 = (Dali::PinchGesture *)jarg1;
36696   result = (float) ((arg1)->scale);
36697   jresult = result;
36698   return jresult;
36699 }
36700
36701
36702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36703   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36704   float arg2 ;
36705
36706   arg1 = (Dali::PinchGesture *)jarg1;
36707   arg2 = (float)jarg2;
36708   if (arg1) (arg1)->speed = arg2;
36709 }
36710
36711
36712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36713   float jresult ;
36714   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36715   float result;
36716
36717   arg1 = (Dali::PinchGesture *)jarg1;
36718   result = (float) ((arg1)->speed);
36719   jresult = result;
36720   return jresult;
36721 }
36722
36723
36724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36725   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36726   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36727
36728   arg1 = (Dali::PinchGesture *)jarg1;
36729   arg2 = (Dali::Vector2 *)jarg2;
36730   if (arg1) (arg1)->screenCenterPoint = *arg2;
36731 }
36732
36733
36734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36735   void * jresult ;
36736   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36737   Dali::Vector2 *result = 0 ;
36738
36739   arg1 = (Dali::PinchGesture *)jarg1;
36740   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36741   jresult = (void *)result;
36742   return jresult;
36743 }
36744
36745
36746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36747   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36748   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36749
36750   arg1 = (Dali::PinchGesture *)jarg1;
36751   arg2 = (Dali::Vector2 *)jarg2;
36752   if (arg1) (arg1)->localCenterPoint = *arg2;
36753 }
36754
36755
36756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36757   void * jresult ;
36758   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36759   Dali::Vector2 *result = 0 ;
36760
36761   arg1 = (Dali::PinchGesture *)jarg1;
36762   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36763   jresult = (void *)result;
36764   return jresult;
36765 }
36766
36767
36768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36769   void * jresult ;
36770   Dali::TapGestureDetector *result = 0 ;
36771
36772   {
36773     try {
36774       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36775     } catch (std::out_of_range& e) {
36776       {
36777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36778       };
36779     } catch (std::exception& e) {
36780       {
36781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36782       };
36783     } catch (...) {
36784       {
36785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36786       };
36787     }
36788   }
36789   jresult = (void *)result;
36790   return jresult;
36791 }
36792
36793
36794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36795   void * jresult ;
36796   Dali::TapGestureDetector result;
36797
36798   {
36799     try {
36800       result = Dali::TapGestureDetector::New();
36801     } catch (std::out_of_range& e) {
36802       {
36803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36804       };
36805     } catch (std::exception& e) {
36806       {
36807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36808       };
36809     } catch (...) {
36810       {
36811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36812       };
36813     }
36814   }
36815   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36816   return jresult;
36817 }
36818
36819
36820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36821   void * jresult ;
36822   unsigned int arg1 ;
36823   Dali::TapGestureDetector result;
36824
36825   arg1 = (unsigned int)jarg1;
36826   {
36827     try {
36828       result = Dali::TapGestureDetector::New(arg1);
36829     } catch (std::out_of_range& e) {
36830       {
36831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36832       };
36833     } catch (std::exception& e) {
36834       {
36835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36836       };
36837     } catch (...) {
36838       {
36839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36840       };
36841     }
36842   }
36843   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36844   return jresult;
36845 }
36846
36847
36848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36849   void * jresult ;
36850   Dali::BaseHandle arg1 ;
36851   Dali::BaseHandle *argp1 ;
36852   Dali::TapGestureDetector result;
36853
36854   argp1 = (Dali::BaseHandle *)jarg1;
36855   if (!argp1) {
36856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36857     return 0;
36858   }
36859   arg1 = *argp1;
36860   {
36861     try {
36862       result = Dali::TapGestureDetector::DownCast(arg1);
36863     } catch (std::out_of_range& e) {
36864       {
36865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36866       };
36867     } catch (std::exception& e) {
36868       {
36869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36870       };
36871     } catch (...) {
36872       {
36873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36874       };
36875     }
36876   }
36877   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36878   return jresult;
36879 }
36880
36881
36882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36883   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36884
36885   arg1 = (Dali::TapGestureDetector *)jarg1;
36886   {
36887     try {
36888       delete arg1;
36889     } catch (std::out_of_range& e) {
36890       {
36891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36892       };
36893     } catch (std::exception& e) {
36894       {
36895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36896       };
36897     } catch (...) {
36898       {
36899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36900       };
36901     }
36902   }
36903 }
36904
36905
36906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36907   void * jresult ;
36908   Dali::TapGestureDetector *arg1 = 0 ;
36909   Dali::TapGestureDetector *result = 0 ;
36910
36911   arg1 = (Dali::TapGestureDetector *)jarg1;
36912   if (!arg1) {
36913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36914     return 0;
36915   }
36916   {
36917     try {
36918       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36919     } catch (std::out_of_range& e) {
36920       {
36921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36922       };
36923     } catch (std::exception& e) {
36924       {
36925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36926       };
36927     } catch (...) {
36928       {
36929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36930       };
36931     }
36932   }
36933   jresult = (void *)result;
36934   return jresult;
36935 }
36936
36937
36938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36939   void * jresult ;
36940   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36941   Dali::TapGestureDetector *arg2 = 0 ;
36942   Dali::TapGestureDetector *result = 0 ;
36943
36944   arg1 = (Dali::TapGestureDetector *)jarg1;
36945   arg2 = (Dali::TapGestureDetector *)jarg2;
36946   if (!arg2) {
36947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36948     return 0;
36949   }
36950   {
36951     try {
36952       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36953     } catch (std::out_of_range& e) {
36954       {
36955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36956       };
36957     } catch (std::exception& e) {
36958       {
36959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36960       };
36961     } catch (...) {
36962       {
36963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36964       };
36965     }
36966   }
36967   jresult = (void *)result;
36968   return jresult;
36969 }
36970
36971
36972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36973   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36974   unsigned int arg2 ;
36975
36976   arg1 = (Dali::TapGestureDetector *)jarg1;
36977   arg2 = (unsigned int)jarg2;
36978   {
36979     try {
36980       (arg1)->SetMinimumTapsRequired(arg2);
36981     } catch (std::out_of_range& e) {
36982       {
36983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36984       };
36985     } catch (std::exception& e) {
36986       {
36987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36988       };
36989     } catch (...) {
36990       {
36991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36992       };
36993     }
36994   }
36995 }
36996
36997
36998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36999   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37000   unsigned int arg2 ;
37001
37002   arg1 = (Dali::TapGestureDetector *)jarg1;
37003   arg2 = (unsigned int)jarg2;
37004   {
37005     try {
37006       (arg1)->SetMaximumTapsRequired(arg2);
37007     } catch (std::out_of_range& e) {
37008       {
37009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37010       };
37011     } catch (std::exception& e) {
37012       {
37013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37014       };
37015     } catch (...) {
37016       {
37017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37018       };
37019     }
37020   }
37021 }
37022
37023
37024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37025   unsigned int jresult ;
37026   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37027   unsigned int result;
37028
37029   arg1 = (Dali::TapGestureDetector *)jarg1;
37030   {
37031     try {
37032       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37033     } catch (std::out_of_range& e) {
37034       {
37035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37036       };
37037     } catch (std::exception& e) {
37038       {
37039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37040       };
37041     } catch (...) {
37042       {
37043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37044       };
37045     }
37046   }
37047   jresult = result;
37048   return jresult;
37049 }
37050
37051
37052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37053   unsigned int jresult ;
37054   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37055   unsigned int result;
37056
37057   arg1 = (Dali::TapGestureDetector *)jarg1;
37058   {
37059     try {
37060       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37061     } catch (std::out_of_range& e) {
37062       {
37063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37064       };
37065     } catch (std::exception& e) {
37066       {
37067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37068       };
37069     } catch (...) {
37070       {
37071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37072       };
37073     }
37074   }
37075   jresult = result;
37076   return jresult;
37077 }
37078
37079
37080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37081   void * jresult ;
37082   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37083   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37084
37085   arg1 = (Dali::TapGestureDetector *)jarg1;
37086   {
37087     try {
37088       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37089     } catch (std::out_of_range& e) {
37090       {
37091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37092       };
37093     } catch (std::exception& e) {
37094       {
37095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37096       };
37097     } catch (...) {
37098       {
37099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37100       };
37101     }
37102   }
37103   jresult = (void *)result;
37104   return jresult;
37105 }
37106
37107
37108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37109   void * jresult ;
37110   Dali::TapGesture *result = 0 ;
37111
37112   {
37113     try {
37114       result = (Dali::TapGesture *)new Dali::TapGesture();
37115     } catch (std::out_of_range& e) {
37116       {
37117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37118       };
37119     } catch (std::exception& e) {
37120       {
37121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37122       };
37123     } catch (...) {
37124       {
37125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37126       };
37127     }
37128   }
37129   jresult = (void *)result;
37130   return jresult;
37131 }
37132
37133
37134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37135   void * jresult ;
37136   Dali::TapGesture *arg1 = 0 ;
37137   Dali::TapGesture *result = 0 ;
37138
37139   arg1 = (Dali::TapGesture *)jarg1;
37140   if (!arg1) {
37141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37142     return 0;
37143   }
37144   {
37145     try {
37146       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37147     } catch (std::out_of_range& e) {
37148       {
37149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37150       };
37151     } catch (std::exception& e) {
37152       {
37153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37154       };
37155     } catch (...) {
37156       {
37157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37158       };
37159     }
37160   }
37161   jresult = (void *)result;
37162   return jresult;
37163 }
37164
37165
37166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37167   void * jresult ;
37168   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37169   Dali::TapGesture *arg2 = 0 ;
37170   Dali::TapGesture *result = 0 ;
37171
37172   arg1 = (Dali::TapGesture *)jarg1;
37173   arg2 = (Dali::TapGesture *)jarg2;
37174   if (!arg2) {
37175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37176     return 0;
37177   }
37178   {
37179     try {
37180       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37181     } catch (std::out_of_range& e) {
37182       {
37183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37184       };
37185     } catch (std::exception& e) {
37186       {
37187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37188       };
37189     } catch (...) {
37190       {
37191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37192       };
37193     }
37194   }
37195   jresult = (void *)result;
37196   return jresult;
37197 }
37198
37199
37200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37201   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37202
37203   arg1 = (Dali::TapGesture *)jarg1;
37204   {
37205     try {
37206       delete arg1;
37207     } catch (std::out_of_range& e) {
37208       {
37209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37210       };
37211     } catch (std::exception& e) {
37212       {
37213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37214       };
37215     } catch (...) {
37216       {
37217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37218       };
37219     }
37220   }
37221 }
37222
37223
37224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37225   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37226   unsigned int arg2 ;
37227
37228   arg1 = (Dali::TapGesture *)jarg1;
37229   arg2 = (unsigned int)jarg2;
37230   if (arg1) (arg1)->numberOfTaps = arg2;
37231 }
37232
37233
37234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37235   unsigned int jresult ;
37236   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37237   unsigned int result;
37238
37239   arg1 = (Dali::TapGesture *)jarg1;
37240   result = (unsigned int) ((arg1)->numberOfTaps);
37241   jresult = result;
37242   return jresult;
37243 }
37244
37245
37246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37247   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37248   unsigned int arg2 ;
37249
37250   arg1 = (Dali::TapGesture *)jarg1;
37251   arg2 = (unsigned int)jarg2;
37252   if (arg1) (arg1)->numberOfTouches = arg2;
37253 }
37254
37255
37256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37257   unsigned int jresult ;
37258   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37259   unsigned int result;
37260
37261   arg1 = (Dali::TapGesture *)jarg1;
37262   result = (unsigned int) ((arg1)->numberOfTouches);
37263   jresult = result;
37264   return jresult;
37265 }
37266
37267
37268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37269   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37270   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37271
37272   arg1 = (Dali::TapGesture *)jarg1;
37273   arg2 = (Dali::Vector2 *)jarg2;
37274   if (arg1) (arg1)->screenPoint = *arg2;
37275 }
37276
37277
37278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37279   void * jresult ;
37280   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37281   Dali::Vector2 *result = 0 ;
37282
37283   arg1 = (Dali::TapGesture *)jarg1;
37284   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37285   jresult = (void *)result;
37286   return jresult;
37287 }
37288
37289
37290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37291   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37292   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37293
37294   arg1 = (Dali::TapGesture *)jarg1;
37295   arg2 = (Dali::Vector2 *)jarg2;
37296   if (arg1) (arg1)->localPoint = *arg2;
37297 }
37298
37299
37300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37301   void * jresult ;
37302   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37303   Dali::Vector2 *result = 0 ;
37304
37305   arg1 = (Dali::TapGesture *)jarg1;
37306   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37307   jresult = (void *)result;
37308   return jresult;
37309 }
37310
37311
37312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37313   void * jresult ;
37314   Dali::AlphaFunction *result = 0 ;
37315
37316   {
37317     try {
37318       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37319     } catch (std::out_of_range& e) {
37320       {
37321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37322       };
37323     } catch (std::exception& e) {
37324       {
37325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37326       };
37327     } catch (...) {
37328       {
37329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37330       };
37331     }
37332   }
37333   jresult = (void *)result;
37334   return jresult;
37335 }
37336
37337
37338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37339   void * jresult ;
37340   Dali::AlphaFunction::BuiltinFunction arg1 ;
37341   Dali::AlphaFunction *result = 0 ;
37342
37343   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37344   {
37345     try {
37346       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37347     } catch (std::out_of_range& e) {
37348       {
37349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37350       };
37351     } catch (std::exception& e) {
37352       {
37353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37354       };
37355     } catch (...) {
37356       {
37357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37358       };
37359     }
37360   }
37361   jresult = (void *)result;
37362   return jresult;
37363 }
37364
37365
37366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37367   void * jresult ;
37368   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37369   Dali::AlphaFunction *result = 0 ;
37370
37371   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37372   {
37373     try {
37374       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37375     } catch (std::out_of_range& e) {
37376       {
37377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37378       };
37379     } catch (std::exception& e) {
37380       {
37381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37382       };
37383     } catch (...) {
37384       {
37385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37386       };
37387     }
37388   }
37389   jresult = (void *)result;
37390   return jresult;
37391 }
37392
37393
37394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37395   void * jresult ;
37396   Dali::Vector2 *arg1 = 0 ;
37397   Dali::Vector2 *arg2 = 0 ;
37398   Dali::AlphaFunction *result = 0 ;
37399
37400   arg1 = (Dali::Vector2 *)jarg1;
37401   if (!arg1) {
37402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37403     return 0;
37404   }
37405   arg2 = (Dali::Vector2 *)jarg2;
37406   if (!arg2) {
37407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37408     return 0;
37409   }
37410   {
37411     try {
37412       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37413     } catch (std::out_of_range& e) {
37414       {
37415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37416       };
37417     } catch (std::exception& e) {
37418       {
37419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37420       };
37421     } catch (...) {
37422       {
37423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37424       };
37425     }
37426   }
37427   jresult = (void *)result;
37428   return jresult;
37429 }
37430
37431
37432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37433   void * jresult ;
37434   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37435   Dali::Vector4 result;
37436
37437   arg1 = (Dali::AlphaFunction *)jarg1;
37438   {
37439     try {
37440       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37441     } catch (std::out_of_range& e) {
37442       {
37443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37444       };
37445     } catch (std::exception& e) {
37446       {
37447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37448       };
37449     } catch (...) {
37450       {
37451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37452       };
37453     }
37454   }
37455   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37456   return jresult;
37457 }
37458
37459
37460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37461   void * jresult ;
37462   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37463   Dali::AlphaFunctionPrototype result;
37464
37465   arg1 = (Dali::AlphaFunction *)jarg1;
37466   {
37467     try {
37468       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37469     } catch (std::out_of_range& e) {
37470       {
37471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37472       };
37473     } catch (std::exception& e) {
37474       {
37475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37476       };
37477     } catch (...) {
37478       {
37479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37480       };
37481     }
37482   }
37483   jresult = (void *)result;
37484   return jresult;
37485 }
37486
37487
37488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37489   int jresult ;
37490   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37491   Dali::AlphaFunction::BuiltinFunction result;
37492
37493   arg1 = (Dali::AlphaFunction *)jarg1;
37494   {
37495     try {
37496       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37497     } catch (std::out_of_range& e) {
37498       {
37499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37500       };
37501     } catch (std::exception& e) {
37502       {
37503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37504       };
37505     } catch (...) {
37506       {
37507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37508       };
37509     }
37510   }
37511   jresult = (int)result;
37512   return jresult;
37513 }
37514
37515
37516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37517   int jresult ;
37518   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37519   Dali::AlphaFunction::Mode result;
37520
37521   arg1 = (Dali::AlphaFunction *)jarg1;
37522   {
37523     try {
37524       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37525     } catch (std::out_of_range& e) {
37526       {
37527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37528       };
37529     } catch (std::exception& e) {
37530       {
37531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37532       };
37533     } catch (...) {
37534       {
37535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37536       };
37537     }
37538   }
37539   jresult = (int)result;
37540   return jresult;
37541 }
37542
37543
37544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37545   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37546
37547   arg1 = (Dali::AlphaFunction *)jarg1;
37548   {
37549     try {
37550       delete arg1;
37551     } catch (std::out_of_range& e) {
37552       {
37553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37554       };
37555     } catch (std::exception& e) {
37556       {
37557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37558       };
37559     } catch (...) {
37560       {
37561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37562       };
37563     }
37564   }
37565 }
37566
37567
37568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37569   void * jresult ;
37570   Dali::KeyFrames result;
37571
37572   {
37573     try {
37574       result = Dali::KeyFrames::New();
37575     } catch (std::out_of_range& e) {
37576       {
37577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37578       };
37579     } catch (std::exception& e) {
37580       {
37581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37582       };
37583     } catch (...) {
37584       {
37585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37586       };
37587     }
37588   }
37589   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37590   return jresult;
37591 }
37592
37593
37594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37595   void * jresult ;
37596   Dali::BaseHandle arg1 ;
37597   Dali::BaseHandle *argp1 ;
37598   Dali::KeyFrames result;
37599
37600   argp1 = (Dali::BaseHandle *)jarg1;
37601   if (!argp1) {
37602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37603     return 0;
37604   }
37605   arg1 = *argp1;
37606   {
37607     try {
37608       result = Dali::KeyFrames::DownCast(arg1);
37609     } catch (std::out_of_range& e) {
37610       {
37611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37612       };
37613     } catch (std::exception& e) {
37614       {
37615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37616       };
37617     } catch (...) {
37618       {
37619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37620       };
37621     }
37622   }
37623   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37624   return jresult;
37625 }
37626
37627
37628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37629   void * jresult ;
37630   Dali::KeyFrames *result = 0 ;
37631
37632   {
37633     try {
37634       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37635     } catch (std::out_of_range& e) {
37636       {
37637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37638       };
37639     } catch (std::exception& e) {
37640       {
37641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37642       };
37643     } catch (...) {
37644       {
37645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37646       };
37647     }
37648   }
37649   jresult = (void *)result;
37650   return jresult;
37651 }
37652
37653
37654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37655   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37656
37657   arg1 = (Dali::KeyFrames *)jarg1;
37658   {
37659     try {
37660       delete arg1;
37661     } catch (std::out_of_range& e) {
37662       {
37663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37664       };
37665     } catch (std::exception& e) {
37666       {
37667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37668       };
37669     } catch (...) {
37670       {
37671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37672       };
37673     }
37674   }
37675 }
37676
37677
37678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37679   void * jresult ;
37680   Dali::KeyFrames *arg1 = 0 ;
37681   Dali::KeyFrames *result = 0 ;
37682
37683   arg1 = (Dali::KeyFrames *)jarg1;
37684   if (!arg1) {
37685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37686     return 0;
37687   }
37688   {
37689     try {
37690       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37691     } catch (std::out_of_range& e) {
37692       {
37693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37694       };
37695     } catch (std::exception& e) {
37696       {
37697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37698       };
37699     } catch (...) {
37700       {
37701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37702       };
37703     }
37704   }
37705   jresult = (void *)result;
37706   return jresult;
37707 }
37708
37709
37710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37711   void * jresult ;
37712   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37713   Dali::KeyFrames *arg2 = 0 ;
37714   Dali::KeyFrames *result = 0 ;
37715
37716   arg1 = (Dali::KeyFrames *)jarg1;
37717   arg2 = (Dali::KeyFrames *)jarg2;
37718   if (!arg2) {
37719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37720     return 0;
37721   }
37722   {
37723     try {
37724       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37725     } catch (std::out_of_range& e) {
37726       {
37727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37728       };
37729     } catch (std::exception& e) {
37730       {
37731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37732       };
37733     } catch (...) {
37734       {
37735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37736       };
37737     }
37738   }
37739   jresult = (void *)result;
37740   return jresult;
37741 }
37742
37743
37744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37745   int jresult ;
37746   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37747   Dali::Property::Type result;
37748
37749   arg1 = (Dali::KeyFrames *)jarg1;
37750   {
37751     try {
37752       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37753     } catch (std::out_of_range& e) {
37754       {
37755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37756       };
37757     } catch (std::exception& e) {
37758       {
37759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37760       };
37761     } catch (...) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37764       };
37765     }
37766   }
37767   jresult = (int)result;
37768   return jresult;
37769 }
37770
37771
37772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37773   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37774   float arg2 ;
37775   Dali::Property::Value arg3 ;
37776   Dali::Property::Value *argp3 ;
37777
37778   arg1 = (Dali::KeyFrames *)jarg1;
37779   arg2 = (float)jarg2;
37780   argp3 = (Dali::Property::Value *)jarg3;
37781   if (!argp3) {
37782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37783     return ;
37784   }
37785   arg3 = *argp3;
37786   {
37787     try {
37788       (arg1)->Add(arg2,arg3);
37789     } catch (std::out_of_range& e) {
37790       {
37791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37792       };
37793     } catch (std::exception& e) {
37794       {
37795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37796       };
37797     } catch (...) {
37798       {
37799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37800       };
37801     }
37802   }
37803 }
37804
37805
37806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37807   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37808   float arg2 ;
37809   Dali::Property::Value arg3 ;
37810   Dali::AlphaFunction arg4 ;
37811   Dali::Property::Value *argp3 ;
37812   Dali::AlphaFunction *argp4 ;
37813
37814   arg1 = (Dali::KeyFrames *)jarg1;
37815   arg2 = (float)jarg2;
37816   argp3 = (Dali::Property::Value *)jarg3;
37817   if (!argp3) {
37818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37819     return ;
37820   }
37821   arg3 = *argp3;
37822   argp4 = (Dali::AlphaFunction *)jarg4;
37823   if (!argp4) {
37824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37825     return ;
37826   }
37827   arg4 = *argp4;
37828   {
37829     try {
37830       (arg1)->Add(arg2,arg3,arg4);
37831     } catch (std::out_of_range& e) {
37832       {
37833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37834       };
37835     } catch (std::exception& e) {
37836       {
37837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37838       };
37839     } catch (...) {
37840       {
37841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37842       };
37843     }
37844   }
37845 }
37846
37847
37848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37849   int jresult ;
37850   int result;
37851
37852   result = (int)Dali::Path::Property::POINTS;
37853   jresult = (int)result;
37854   return jresult;
37855 }
37856
37857
37858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37859   int jresult ;
37860   int result;
37861
37862   result = (int)Dali::Path::Property::CONTROL_POINTS;
37863   jresult = (int)result;
37864   return jresult;
37865 }
37866
37867
37868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37869   void * jresult ;
37870   Dali::Path::Property *result = 0 ;
37871
37872   {
37873     try {
37874       result = (Dali::Path::Property *)new Dali::Path::Property();
37875     } catch (std::out_of_range& e) {
37876       {
37877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37878       };
37879     } catch (std::exception& e) {
37880       {
37881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37882       };
37883     } catch (...) {
37884       {
37885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37886       };
37887     }
37888   }
37889   jresult = (void *)result;
37890   return jresult;
37891 }
37892
37893
37894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37895   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37896
37897   arg1 = (Dali::Path::Property *)jarg1;
37898   {
37899     try {
37900       delete arg1;
37901     } catch (std::out_of_range& e) {
37902       {
37903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37904       };
37905     } catch (std::exception& e) {
37906       {
37907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37908       };
37909     } catch (...) {
37910       {
37911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37912       };
37913     }
37914   }
37915 }
37916
37917
37918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37919   void * jresult ;
37920   Dali::Path result;
37921
37922   {
37923     try {
37924       result = Dali::Path::New();
37925     } catch (std::out_of_range& e) {
37926       {
37927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37928       };
37929     } catch (std::exception& e) {
37930       {
37931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37932       };
37933     } catch (...) {
37934       {
37935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37936       };
37937     }
37938   }
37939   jresult = new Dali::Path((const Dali::Path &)result);
37940   return jresult;
37941 }
37942
37943
37944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37945   void * jresult ;
37946   Dali::BaseHandle arg1 ;
37947   Dali::BaseHandle *argp1 ;
37948   Dali::Path result;
37949
37950   argp1 = (Dali::BaseHandle *)jarg1;
37951   if (!argp1) {
37952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37953     return 0;
37954   }
37955   arg1 = *argp1;
37956   {
37957     try {
37958       result = Dali::Path::DownCast(arg1);
37959     } catch (std::out_of_range& e) {
37960       {
37961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37962       };
37963     } catch (std::exception& e) {
37964       {
37965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37966       };
37967     } catch (...) {
37968       {
37969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37970       };
37971     }
37972   }
37973   jresult = new Dali::Path((const Dali::Path &)result);
37974   return jresult;
37975 }
37976
37977
37978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37979   void * jresult ;
37980   Dali::Path *result = 0 ;
37981
37982   {
37983     try {
37984       result = (Dali::Path *)new Dali::Path();
37985     } catch (std::out_of_range& e) {
37986       {
37987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37988       };
37989     } catch (std::exception& e) {
37990       {
37991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37992       };
37993     } catch (...) {
37994       {
37995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37996       };
37997     }
37998   }
37999   jresult = (void *)result;
38000   return jresult;
38001 }
38002
38003
38004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38005   Dali::Path *arg1 = (Dali::Path *) 0 ;
38006
38007   arg1 = (Dali::Path *)jarg1;
38008   {
38009     try {
38010       delete arg1;
38011     } catch (std::out_of_range& e) {
38012       {
38013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38014       };
38015     } catch (std::exception& e) {
38016       {
38017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38018       };
38019     } catch (...) {
38020       {
38021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38022       };
38023     }
38024   }
38025 }
38026
38027
38028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38029   void * jresult ;
38030   Dali::Path *arg1 = 0 ;
38031   Dali::Path *result = 0 ;
38032
38033   arg1 = (Dali::Path *)jarg1;
38034   if (!arg1) {
38035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38036     return 0;
38037   }
38038   {
38039     try {
38040       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38041     } catch (std::out_of_range& e) {
38042       {
38043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38044       };
38045     } catch (std::exception& e) {
38046       {
38047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38048       };
38049     } catch (...) {
38050       {
38051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38052       };
38053     }
38054   }
38055   jresult = (void *)result;
38056   return jresult;
38057 }
38058
38059
38060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38061   void * jresult ;
38062   Dali::Path *arg1 = (Dali::Path *) 0 ;
38063   Dali::Path *arg2 = 0 ;
38064   Dali::Path *result = 0 ;
38065
38066   arg1 = (Dali::Path *)jarg1;
38067   arg2 = (Dali::Path *)jarg2;
38068   if (!arg2) {
38069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38070     return 0;
38071   }
38072   {
38073     try {
38074       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38075     } catch (std::out_of_range& e) {
38076       {
38077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38078       };
38079     } catch (std::exception& e) {
38080       {
38081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38082       };
38083     } catch (...) {
38084       {
38085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38086       };
38087     }
38088   }
38089   jresult = (void *)result;
38090   return jresult;
38091 }
38092
38093
38094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38095   Dali::Path *arg1 = (Dali::Path *) 0 ;
38096   Dali::Vector3 *arg2 = 0 ;
38097
38098   arg1 = (Dali::Path *)jarg1;
38099   arg2 = (Dali::Vector3 *)jarg2;
38100   if (!arg2) {
38101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38102     return ;
38103   }
38104   {
38105     try {
38106       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38107     } catch (std::out_of_range& e) {
38108       {
38109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38110       };
38111     } catch (std::exception& e) {
38112       {
38113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38114       };
38115     } catch (...) {
38116       {
38117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38118       };
38119     }
38120   }
38121 }
38122
38123
38124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38125   Dali::Path *arg1 = (Dali::Path *) 0 ;
38126   Dali::Vector3 *arg2 = 0 ;
38127
38128   arg1 = (Dali::Path *)jarg1;
38129   arg2 = (Dali::Vector3 *)jarg2;
38130   if (!arg2) {
38131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38132     return ;
38133   }
38134   {
38135     try {
38136       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38137     } catch (std::out_of_range& e) {
38138       {
38139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38140       };
38141     } catch (std::exception& e) {
38142       {
38143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38144       };
38145     } catch (...) {
38146       {
38147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38148       };
38149     }
38150   }
38151 }
38152
38153
38154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38155   Dali::Path *arg1 = (Dali::Path *) 0 ;
38156   float arg2 ;
38157
38158   arg1 = (Dali::Path *)jarg1;
38159   arg2 = (float)jarg2;
38160   {
38161     try {
38162       (arg1)->GenerateControlPoints(arg2);
38163     } catch (std::out_of_range& e) {
38164       {
38165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38166       };
38167     } catch (std::exception& e) {
38168       {
38169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38170       };
38171     } catch (...) {
38172       {
38173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38174       };
38175     }
38176   }
38177 }
38178
38179
38180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38181   Dali::Path *arg1 = (Dali::Path *) 0 ;
38182   float arg2 ;
38183   Dali::Vector3 *arg3 = 0 ;
38184   Dali::Vector3 *arg4 = 0 ;
38185
38186   arg1 = (Dali::Path *)jarg1;
38187   arg2 = (float)jarg2;
38188   arg3 = (Dali::Vector3 *)jarg3;
38189   if (!arg3) {
38190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38191     return ;
38192   }
38193   arg4 = (Dali::Vector3 *)jarg4;
38194   if (!arg4) {
38195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38196     return ;
38197   }
38198   {
38199     try {
38200       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38201     } catch (std::out_of_range& e) {
38202       {
38203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38204       };
38205     } catch (std::exception& e) {
38206       {
38207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38208       };
38209     } catch (...) {
38210       {
38211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38212       };
38213     }
38214   }
38215 }
38216
38217
38218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38219   void * jresult ;
38220   Dali::Path *arg1 = (Dali::Path *) 0 ;
38221   size_t arg2 ;
38222   Dali::Vector3 *result = 0 ;
38223
38224   arg1 = (Dali::Path *)jarg1;
38225   arg2 = (size_t)jarg2;
38226   {
38227     try {
38228       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38229     } catch (std::out_of_range& e) {
38230       {
38231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38232       };
38233     } catch (std::exception& e) {
38234       {
38235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38236       };
38237     } catch (...) {
38238       {
38239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38240       };
38241     }
38242   }
38243   jresult = (void *)result;
38244   return jresult;
38245 }
38246
38247
38248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38249   void * jresult ;
38250   Dali::Path *arg1 = (Dali::Path *) 0 ;
38251   size_t arg2 ;
38252   Dali::Vector3 *result = 0 ;
38253
38254   arg1 = (Dali::Path *)jarg1;
38255   arg2 = (size_t)jarg2;
38256   {
38257     try {
38258       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38259     } catch (std::out_of_range& e) {
38260       {
38261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38262       };
38263     } catch (std::exception& e) {
38264       {
38265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38266       };
38267     } catch (...) {
38268       {
38269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38270       };
38271     }
38272   }
38273   jresult = (void *)result;
38274   return jresult;
38275 }
38276
38277
38278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38279   unsigned long jresult ;
38280   Dali::Path *arg1 = (Dali::Path *) 0 ;
38281   size_t result;
38282
38283   arg1 = (Dali::Path *)jarg1;
38284   {
38285     try {
38286       result = ((Dali::Path const *)arg1)->GetPointCount();
38287     } catch (std::out_of_range& e) {
38288       {
38289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38290       };
38291     } catch (std::exception& e) {
38292       {
38293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38294       };
38295     } catch (...) {
38296       {
38297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38298       };
38299     }
38300   }
38301   jresult = (unsigned long)result;
38302   return jresult;
38303 }
38304
38305
38306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38307   void * jresult ;
38308   float arg1 ;
38309   Dali::TimePeriod *result = 0 ;
38310
38311   arg1 = (float)jarg1;
38312   {
38313     try {
38314       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38315     } catch (std::out_of_range& e) {
38316       {
38317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38318       };
38319     } catch (std::exception& e) {
38320       {
38321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38322       };
38323     } catch (...) {
38324       {
38325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38326       };
38327     }
38328   }
38329   jresult = (void *)result;
38330   return jresult;
38331 }
38332
38333
38334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38335   void * jresult ;
38336   float arg1 ;
38337   float arg2 ;
38338   Dali::TimePeriod *result = 0 ;
38339
38340   arg1 = (float)jarg1;
38341   arg2 = (float)jarg2;
38342   {
38343     try {
38344       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38345     } catch (std::out_of_range& e) {
38346       {
38347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38348       };
38349     } catch (std::exception& e) {
38350       {
38351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38352       };
38353     } catch (...) {
38354       {
38355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38356       };
38357     }
38358   }
38359   jresult = (void *)result;
38360   return jresult;
38361 }
38362
38363
38364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38365   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38366
38367   arg1 = (Dali::TimePeriod *)jarg1;
38368   {
38369     try {
38370       delete arg1;
38371     } catch (std::out_of_range& e) {
38372       {
38373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38374       };
38375     } catch (std::exception& e) {
38376       {
38377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38378       };
38379     } catch (...) {
38380       {
38381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38382       };
38383     }
38384   }
38385 }
38386
38387
38388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38389   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38390   float arg2 ;
38391
38392   arg1 = (Dali::TimePeriod *)jarg1;
38393   arg2 = (float)jarg2;
38394   if (arg1) (arg1)->delaySeconds = arg2;
38395 }
38396
38397
38398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38399   float jresult ;
38400   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38401   float result;
38402
38403   arg1 = (Dali::TimePeriod *)jarg1;
38404   result = (float) ((arg1)->delaySeconds);
38405   jresult = result;
38406   return jresult;
38407 }
38408
38409
38410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38411   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38412   float arg2 ;
38413
38414   arg1 = (Dali::TimePeriod *)jarg1;
38415   arg2 = (float)jarg2;
38416   if (arg1) (arg1)->durationSeconds = arg2;
38417 }
38418
38419
38420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38421   float jresult ;
38422   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38423   float result;
38424
38425   arg1 = (Dali::TimePeriod *)jarg1;
38426   result = (float) ((arg1)->durationSeconds);
38427   jresult = result;
38428   return jresult;
38429 }
38430
38431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
38432   int jresult ;
38433   int result;
38434
38435   result = (int)Dali::LinearConstrainer::Property::VALUE;
38436   jresult = (int)result;
38437   return jresult;
38438 }
38439
38440
38441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
38442   int jresult ;
38443   int result;
38444
38445   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
38446   jresult = (int)result;
38447   return jresult;
38448 }
38449
38450
38451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
38452   void * jresult ;
38453   Dali::LinearConstrainer::Property *result = 0 ;
38454
38455   {
38456     try {
38457       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
38458     } catch (std::out_of_range& e) {
38459       {
38460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38461       };
38462     } catch (std::exception& e) {
38463       {
38464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38465       };
38466     } catch (...) {
38467       {
38468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38469       };
38470     }
38471   }
38472   jresult = (void *)result;
38473   return jresult;
38474 }
38475
38476
38477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
38478   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
38479
38480   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
38481   {
38482     try {
38483       delete arg1;
38484     } catch (std::out_of_range& e) {
38485       {
38486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38487       };
38488     } catch (std::exception& e) {
38489       {
38490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38491       };
38492     } catch (...) {
38493       {
38494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38495       };
38496     }
38497   }
38498 }
38499
38500
38501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
38502   void * jresult ;
38503   Dali::LinearConstrainer result;
38504
38505   {
38506     try {
38507       result = Dali::LinearConstrainer::New();
38508     } catch (std::out_of_range& e) {
38509       {
38510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38511       };
38512     } catch (std::exception& e) {
38513       {
38514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38515       };
38516     } catch (...) {
38517       {
38518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38519       };
38520     }
38521   }
38522   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38523   return jresult;
38524 }
38525
38526
38527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
38528   void * jresult ;
38529   Dali::BaseHandle arg1 ;
38530   Dali::BaseHandle *argp1 ;
38531   Dali::LinearConstrainer result;
38532
38533   argp1 = (Dali::BaseHandle *)jarg1;
38534   if (!argp1) {
38535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38536     return 0;
38537   }
38538   arg1 = *argp1;
38539   {
38540     try {
38541       result = Dali::LinearConstrainer::DownCast(arg1);
38542     } catch (std::out_of_range& e) {
38543       {
38544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38545       };
38546     } catch (std::exception& e) {
38547       {
38548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38549       };
38550     } catch (...) {
38551       {
38552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38553       };
38554     }
38555   }
38556   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38557   return jresult;
38558 }
38559
38560
38561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
38562   void * jresult ;
38563   Dali::LinearConstrainer *result = 0 ;
38564
38565   {
38566     try {
38567       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
38568     } catch (std::out_of_range& e) {
38569       {
38570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38571       };
38572     } catch (std::exception& e) {
38573       {
38574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38575       };
38576     } catch (...) {
38577       {
38578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38579       };
38580     }
38581   }
38582   jresult = (void *)result;
38583   return jresult;
38584 }
38585
38586
38587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
38588   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38589
38590   arg1 = (Dali::LinearConstrainer *)jarg1;
38591   {
38592     try {
38593       delete arg1;
38594     } catch (std::out_of_range& e) {
38595       {
38596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38597       };
38598     } catch (std::exception& e) {
38599       {
38600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38601       };
38602     } catch (...) {
38603       {
38604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38605       };
38606     }
38607   }
38608 }
38609
38610
38611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
38612   void * jresult ;
38613   Dali::LinearConstrainer *arg1 = 0 ;
38614   Dali::LinearConstrainer *result = 0 ;
38615
38616   arg1 = (Dali::LinearConstrainer *)jarg1;
38617   if (!arg1) {
38618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38619     return 0;
38620   }
38621   {
38622     try {
38623       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
38624     } catch (std::out_of_range& e) {
38625       {
38626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38627       };
38628     } catch (std::exception& e) {
38629       {
38630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38631       };
38632     } catch (...) {
38633       {
38634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38635       };
38636     }
38637   }
38638   jresult = (void *)result;
38639   return jresult;
38640 }
38641
38642
38643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
38644   void * jresult ;
38645   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38646   Dali::LinearConstrainer *arg2 = 0 ;
38647   Dali::LinearConstrainer *result = 0 ;
38648
38649   arg1 = (Dali::LinearConstrainer *)jarg1;
38650   arg2 = (Dali::LinearConstrainer *)jarg2;
38651   if (!arg2) {
38652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38653     return 0;
38654   }
38655   {
38656     try {
38657       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
38658     } catch (std::out_of_range& e) {
38659       {
38660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38661       };
38662     } catch (std::exception& e) {
38663       {
38664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38665       };
38666     } catch (...) {
38667       {
38668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38669       };
38670     }
38671   }
38672   jresult = (void *)result;
38673   return jresult;
38674 }
38675
38676
38677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38678   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38679   SwigValueWrapper< Dali::Property > arg2 ;
38680   SwigValueWrapper< Dali::Property > arg3 ;
38681   Dali::Vector2 *arg4 = 0 ;
38682   Dali::Vector2 *arg5 = 0 ;
38683   Dali::Property *argp2 ;
38684   Dali::Property *argp3 ;
38685
38686   arg1 = (Dali::LinearConstrainer *)jarg1;
38687   argp2 = (Dali::Property *)jarg2;
38688   if (!argp2) {
38689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38690     return ;
38691   }
38692   arg2 = *argp2;
38693   argp3 = (Dali::Property *)jarg3;
38694   if (!argp3) {
38695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38696     return ;
38697   }
38698   arg3 = *argp3;
38699   arg4 = (Dali::Vector2 *)jarg4;
38700   if (!arg4) {
38701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38702     return ;
38703   }
38704   arg5 = (Dali::Vector2 *)jarg5;
38705   if (!arg5) {
38706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38707     return ;
38708   }
38709   {
38710     try {
38711       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
38712     } catch (std::out_of_range& e) {
38713       {
38714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38715       };
38716     } catch (std::exception& e) {
38717       {
38718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38719       };
38720     } catch (...) {
38721       {
38722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38723       };
38724     }
38725   }
38726 }
38727
38728
38729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
38730   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38731   SwigValueWrapper< Dali::Property > arg2 ;
38732   SwigValueWrapper< Dali::Property > arg3 ;
38733   Dali::Vector2 *arg4 = 0 ;
38734   Dali::Property *argp2 ;
38735   Dali::Property *argp3 ;
38736
38737   arg1 = (Dali::LinearConstrainer *)jarg1;
38738   argp2 = (Dali::Property *)jarg2;
38739   if (!argp2) {
38740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38741     return ;
38742   }
38743   arg2 = *argp2;
38744   argp3 = (Dali::Property *)jarg3;
38745   if (!argp3) {
38746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38747     return ;
38748   }
38749   arg3 = *argp3;
38750   arg4 = (Dali::Vector2 *)jarg4;
38751   if (!arg4) {
38752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38753     return ;
38754   }
38755   {
38756     try {
38757       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
38758     } catch (std::out_of_range& e) {
38759       {
38760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38761       };
38762     } catch (std::exception& e) {
38763       {
38764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38765       };
38766     } catch (...) {
38767       {
38768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38769       };
38770     }
38771   }
38772 }
38773
38774
38775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
38776   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38777   Dali::Handle *arg2 = 0 ;
38778
38779   arg1 = (Dali::LinearConstrainer *)jarg1;
38780   arg2 = (Dali::Handle *)jarg2;
38781   if (!arg2) {
38782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
38783     return ;
38784   }
38785   {
38786     try {
38787       (arg1)->Remove(*arg2);
38788     } catch (std::out_of_range& e) {
38789       {
38790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38791       };
38792     } catch (std::exception& e) {
38793       {
38794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38795       };
38796     } catch (...) {
38797       {
38798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38799       };
38800     }
38801   }
38802 }
38803
38804
38805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
38806   int jresult ;
38807   int result;
38808
38809   result = (int)Dali::PathConstrainer::Property::FORWARD;
38810   jresult = (int)result;
38811   return jresult;
38812 }
38813
38814
38815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
38816   int jresult ;
38817   int result;
38818
38819   result = (int)Dali::PathConstrainer::Property::POINTS;
38820   jresult = (int)result;
38821   return jresult;
38822 }
38823
38824
38825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
38826   int jresult ;
38827   int result;
38828
38829   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
38830   jresult = (int)result;
38831   return jresult;
38832 }
38833
38834
38835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
38836   void * jresult ;
38837   Dali::PathConstrainer::Property *result = 0 ;
38838
38839   {
38840     try {
38841       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
38842     } catch (std::out_of_range& e) {
38843       {
38844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38845       };
38846     } catch (std::exception& e) {
38847       {
38848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38849       };
38850     } catch (...) {
38851       {
38852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38853       };
38854     }
38855   }
38856   jresult = (void *)result;
38857   return jresult;
38858 }
38859
38860
38861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
38862   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
38863
38864   arg1 = (Dali::PathConstrainer::Property *)jarg1;
38865   {
38866     try {
38867       delete arg1;
38868     } catch (std::out_of_range& e) {
38869       {
38870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38871       };
38872     } catch (std::exception& e) {
38873       {
38874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38875       };
38876     } catch (...) {
38877       {
38878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38879       };
38880     }
38881   }
38882 }
38883
38884
38885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
38886   void * jresult ;
38887   Dali::PathConstrainer result;
38888
38889   {
38890     try {
38891       result = Dali::PathConstrainer::New();
38892     } catch (std::out_of_range& e) {
38893       {
38894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38895       };
38896     } catch (std::exception& e) {
38897       {
38898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38899       };
38900     } catch (...) {
38901       {
38902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38903       };
38904     }
38905   }
38906   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38907   return jresult;
38908 }
38909
38910
38911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
38912   void * jresult ;
38913   Dali::BaseHandle arg1 ;
38914   Dali::BaseHandle *argp1 ;
38915   Dali::PathConstrainer result;
38916
38917   argp1 = (Dali::BaseHandle *)jarg1;
38918   if (!argp1) {
38919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38920     return 0;
38921   }
38922   arg1 = *argp1;
38923   {
38924     try {
38925       result = Dali::PathConstrainer::DownCast(arg1);
38926     } catch (std::out_of_range& e) {
38927       {
38928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38929       };
38930     } catch (std::exception& e) {
38931       {
38932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38933       };
38934     } catch (...) {
38935       {
38936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38937       };
38938     }
38939   }
38940   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38941   return jresult;
38942 }
38943
38944
38945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
38946   void * jresult ;
38947   Dali::PathConstrainer *result = 0 ;
38948
38949   {
38950     try {
38951       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
38952     } catch (std::out_of_range& e) {
38953       {
38954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38955       };
38956     } catch (std::exception& e) {
38957       {
38958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38959       };
38960     } catch (...) {
38961       {
38962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38963       };
38964     }
38965   }
38966   jresult = (void *)result;
38967   return jresult;
38968 }
38969
38970
38971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
38972   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
38973
38974   arg1 = (Dali::PathConstrainer *)jarg1;
38975   {
38976     try {
38977       delete arg1;
38978     } catch (std::out_of_range& e) {
38979       {
38980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38981       };
38982     } catch (std::exception& e) {
38983       {
38984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38985       };
38986     } catch (...) {
38987       {
38988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38989       };
38990     }
38991   }
38992 }
38993
38994
38995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
38996   void * jresult ;
38997   Dali::PathConstrainer *arg1 = 0 ;
38998   Dali::PathConstrainer *result = 0 ;
38999
39000   arg1 = (Dali::PathConstrainer *)jarg1;
39001   if (!arg1) {
39002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39003     return 0;
39004   }
39005   {
39006     try {
39007       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
39008     } catch (std::out_of_range& e) {
39009       {
39010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39011       };
39012     } catch (std::exception& e) {
39013       {
39014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39015       };
39016     } catch (...) {
39017       {
39018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39019       };
39020     }
39021   }
39022   jresult = (void *)result;
39023   return jresult;
39024 }
39025
39026
39027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
39028   void * jresult ;
39029   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39030   Dali::PathConstrainer *arg2 = 0 ;
39031   Dali::PathConstrainer *result = 0 ;
39032
39033   arg1 = (Dali::PathConstrainer *)jarg1;
39034   arg2 = (Dali::PathConstrainer *)jarg2;
39035   if (!arg2) {
39036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39037     return 0;
39038   }
39039   {
39040     try {
39041       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
39042     } catch (std::out_of_range& e) {
39043       {
39044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39045       };
39046     } catch (std::exception& e) {
39047       {
39048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39049       };
39050     } catch (...) {
39051       {
39052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39053       };
39054     }
39055   }
39056   jresult = (void *)result;
39057   return jresult;
39058 }
39059
39060
39061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39062   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39063   SwigValueWrapper< Dali::Property > arg2 ;
39064   SwigValueWrapper< Dali::Property > arg3 ;
39065   Dali::Vector2 *arg4 = 0 ;
39066   Dali::Vector2 *arg5 = 0 ;
39067   Dali::Property *argp2 ;
39068   Dali::Property *argp3 ;
39069
39070   arg1 = (Dali::PathConstrainer *)jarg1;
39071   argp2 = (Dali::Property *)jarg2;
39072   if (!argp2) {
39073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39074     return ;
39075   }
39076   arg2 = *argp2;
39077   argp3 = (Dali::Property *)jarg3;
39078   if (!argp3) {
39079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39080     return ;
39081   }
39082   arg3 = *argp3;
39083   arg4 = (Dali::Vector2 *)jarg4;
39084   if (!arg4) {
39085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39086     return ;
39087   }
39088   arg5 = (Dali::Vector2 *)jarg5;
39089   if (!arg5) {
39090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39091     return ;
39092   }
39093   {
39094     try {
39095       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
39096     } catch (std::out_of_range& e) {
39097       {
39098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39099       };
39100     } catch (std::exception& e) {
39101       {
39102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39103       };
39104     } catch (...) {
39105       {
39106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39107       };
39108     }
39109   }
39110 }
39111
39112
39113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39114   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39115   SwigValueWrapper< Dali::Property > arg2 ;
39116   SwigValueWrapper< Dali::Property > arg3 ;
39117   Dali::Vector2 *arg4 = 0 ;
39118   Dali::Property *argp2 ;
39119   Dali::Property *argp3 ;
39120
39121   arg1 = (Dali::PathConstrainer *)jarg1;
39122   argp2 = (Dali::Property *)jarg2;
39123   if (!argp2) {
39124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39125     return ;
39126   }
39127   arg2 = *argp2;
39128   argp3 = (Dali::Property *)jarg3;
39129   if (!argp3) {
39130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39131     return ;
39132   }
39133   arg3 = *argp3;
39134   arg4 = (Dali::Vector2 *)jarg4;
39135   if (!arg4) {
39136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39137     return ;
39138   }
39139   {
39140     try {
39141       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
39142     } catch (std::out_of_range& e) {
39143       {
39144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39145       };
39146     } catch (std::exception& e) {
39147       {
39148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39149       };
39150     } catch (...) {
39151       {
39152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39153       };
39154     }
39155   }
39156 }
39157
39158
39159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
39160   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39161   Dali::Handle *arg2 = 0 ;
39162
39163   arg1 = (Dali::PathConstrainer *)jarg1;
39164   arg2 = (Dali::Handle *)jarg2;
39165   if (!arg2) {
39166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
39167     return ;
39168   }
39169   {
39170     try {
39171       (arg1)->Remove(*arg2);
39172     } catch (std::out_of_range& e) {
39173       {
39174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39175       };
39176     } catch (std::exception& e) {
39177       {
39178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39179       };
39180     } catch (...) {
39181       {
39182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39183       };
39184     }
39185   }
39186 }
39187
39188
39189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
39190   int jresult ;
39191   Dali::FittingMode::Type result;
39192
39193   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
39194   jresult = (int)result;
39195   return jresult;
39196 }
39197
39198
39199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
39200   int jresult ;
39201   Dali::SamplingMode::Type result;
39202
39203   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
39204   jresult = (int)result;
39205   return jresult;
39206 }
39207
39208
39209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
39210   void * jresult ;
39211   Dali::BufferImage *result = 0 ;
39212
39213   {
39214     try {
39215       result = (Dali::BufferImage *)new Dali::BufferImage();
39216     } catch (std::out_of_range& e) {
39217       {
39218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39219       };
39220     } catch (std::exception& e) {
39221       {
39222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39223       };
39224     } catch (...) {
39225       {
39226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39227       };
39228     }
39229   }
39230   jresult = (void *)result;
39231   return jresult;
39232 }
39233
39234
39235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
39236   void * jresult ;
39237   unsigned int arg1 ;
39238   unsigned int arg2 ;
39239   Dali::Pixel::Format arg3 ;
39240   Dali::BufferImage result;
39241
39242   arg1 = (unsigned int)jarg1;
39243   arg2 = (unsigned int)jarg2;
39244   arg3 = (Dali::Pixel::Format)jarg3;
39245   {
39246     try {
39247       result = Dali::BufferImage::New(arg1,arg2,arg3);
39248     } catch (std::out_of_range& e) {
39249       {
39250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39251       };
39252     } catch (std::exception& e) {
39253       {
39254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39255       };
39256     } catch (...) {
39257       {
39258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39259       };
39260     }
39261   }
39262   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39263   return jresult;
39264 }
39265
39266
39267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
39268   void * jresult ;
39269   unsigned int arg1 ;
39270   unsigned int arg2 ;
39271   Dali::BufferImage result;
39272
39273   arg1 = (unsigned int)jarg1;
39274   arg2 = (unsigned int)jarg2;
39275   {
39276     try {
39277       result = Dali::BufferImage::New(arg1,arg2);
39278     } catch (std::out_of_range& e) {
39279       {
39280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39281       };
39282     } catch (std::exception& e) {
39283       {
39284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39285       };
39286     } catch (...) {
39287       {
39288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39289       };
39290     }
39291   }
39292   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39293   return jresult;
39294 }
39295
39296
39297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
39298   void * jresult ;
39299   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39300   unsigned int arg2 ;
39301   unsigned int arg3 ;
39302   Dali::Pixel::Format arg4 ;
39303   unsigned int arg5 ;
39304   Dali::BufferImage result;
39305
39306   arg1 = jarg1;
39307   arg2 = (unsigned int)jarg2;
39308   arg3 = (unsigned int)jarg3;
39309   arg4 = (Dali::Pixel::Format)jarg4;
39310   arg5 = (unsigned int)jarg5;
39311   {
39312     try {
39313       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
39314     } catch (std::out_of_range& e) {
39315       {
39316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39317       };
39318     } catch (std::exception& e) {
39319       {
39320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39321       };
39322     } catch (...) {
39323       {
39324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39325       };
39326     }
39327   }
39328   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39329
39330
39331   return jresult;
39332 }
39333
39334
39335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
39336   void * jresult ;
39337   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39338   unsigned int arg2 ;
39339   unsigned int arg3 ;
39340   Dali::Pixel::Format arg4 ;
39341   Dali::BufferImage result;
39342
39343   arg1 = jarg1;
39344   arg2 = (unsigned int)jarg2;
39345   arg3 = (unsigned int)jarg3;
39346   arg4 = (Dali::Pixel::Format)jarg4;
39347   {
39348     try {
39349       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
39350     } catch (std::out_of_range& e) {
39351       {
39352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39353       };
39354     } catch (std::exception& e) {
39355       {
39356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39357       };
39358     } catch (...) {
39359       {
39360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39361       };
39362     }
39363   }
39364   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39365
39366
39367   return jresult;
39368 }
39369
39370
39371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
39372   void * jresult ;
39373   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39374   unsigned int arg2 ;
39375   unsigned int arg3 ;
39376   Dali::BufferImage result;
39377
39378   arg1 = jarg1;
39379   arg2 = (unsigned int)jarg2;
39380   arg3 = (unsigned int)jarg3;
39381   {
39382     try {
39383       result = Dali::BufferImage::New(arg1,arg2,arg3);
39384     } catch (std::out_of_range& e) {
39385       {
39386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39387       };
39388     } catch (std::exception& e) {
39389       {
39390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39391       };
39392     } catch (...) {
39393       {
39394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39395       };
39396     }
39397   }
39398   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39399
39400
39401   return jresult;
39402 }
39403
39404
39405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
39406   void * jresult ;
39407   Dali::BaseHandle arg1 ;
39408   Dali::BaseHandle *argp1 ;
39409   Dali::BufferImage result;
39410
39411   argp1 = (Dali::BaseHandle *)jarg1;
39412   if (!argp1) {
39413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39414     return 0;
39415   }
39416   arg1 = *argp1;
39417   {
39418     try {
39419       result = Dali::BufferImage::DownCast(arg1);
39420     } catch (std::out_of_range& e) {
39421       {
39422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39423       };
39424     } catch (std::exception& e) {
39425       {
39426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39427       };
39428     } catch (...) {
39429       {
39430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39431       };
39432     }
39433   }
39434   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39435   return jresult;
39436 }
39437
39438
39439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
39440   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39441
39442   arg1 = (Dali::BufferImage *)jarg1;
39443   {
39444     try {
39445       delete arg1;
39446     } catch (std::out_of_range& e) {
39447       {
39448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39449       };
39450     } catch (std::exception& e) {
39451       {
39452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39453       };
39454     } catch (...) {
39455       {
39456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39457       };
39458     }
39459   }
39460 }
39461
39462
39463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
39464   void * jresult ;
39465   Dali::BufferImage *arg1 = 0 ;
39466   Dali::BufferImage *result = 0 ;
39467
39468   arg1 = (Dali::BufferImage *)jarg1;
39469   if (!arg1) {
39470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39471     return 0;
39472   }
39473   {
39474     try {
39475       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
39476     } catch (std::out_of_range& e) {
39477       {
39478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39479       };
39480     } catch (std::exception& e) {
39481       {
39482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39483       };
39484     } catch (...) {
39485       {
39486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39487       };
39488     }
39489   }
39490   jresult = (void *)result;
39491   return jresult;
39492 }
39493
39494
39495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
39496   void * jresult ;
39497   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39498   Dali::BufferImage *arg2 = 0 ;
39499   Dali::BufferImage *result = 0 ;
39500
39501   arg1 = (Dali::BufferImage *)jarg1;
39502   arg2 = (Dali::BufferImage *)jarg2;
39503   if (!arg2) {
39504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39505     return 0;
39506   }
39507   {
39508     try {
39509       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
39510     } catch (std::out_of_range& e) {
39511       {
39512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39513       };
39514     } catch (std::exception& e) {
39515       {
39516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39517       };
39518     } catch (...) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39521       };
39522     }
39523   }
39524   jresult = (void *)result;
39525   return jresult;
39526 }
39527
39528
39529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
39530   void * jresult ;
39531   Dali::BufferImage result;
39532
39533   {
39534     try {
39535       result = Dali::BufferImage::WHITE();
39536     } catch (std::out_of_range& e) {
39537       {
39538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39539       };
39540     } catch (std::exception& e) {
39541       {
39542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39543       };
39544     } catch (...) {
39545       {
39546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39547       };
39548     }
39549   }
39550   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39551   return jresult;
39552 }
39553
39554
39555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
39556   void * jresult ;
39557   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39558   Dali::PixelBuffer *result = 0 ;
39559
39560   arg1 = (Dali::BufferImage *)jarg1;
39561   {
39562     try {
39563       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
39564     } catch (std::out_of_range& e) {
39565       {
39566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39567       };
39568     } catch (std::exception& e) {
39569       {
39570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39571       };
39572     } catch (...) {
39573       {
39574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39575       };
39576     }
39577   }
39578   jresult = (void *)result;
39579   return jresult;
39580 }
39581
39582
39583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
39584   unsigned int jresult ;
39585   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39586   unsigned int result;
39587
39588   arg1 = (Dali::BufferImage *)jarg1;
39589   {
39590     try {
39591       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
39592     } catch (std::out_of_range& e) {
39593       {
39594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39595       };
39596     } catch (std::exception& e) {
39597       {
39598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39599       };
39600     } catch (...) {
39601       {
39602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39603       };
39604     }
39605   }
39606   jresult = result;
39607   return jresult;
39608 }
39609
39610
39611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
39612   unsigned int jresult ;
39613   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39614   unsigned int result;
39615
39616   arg1 = (Dali::BufferImage *)jarg1;
39617   {
39618     try {
39619       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
39620     } catch (std::out_of_range& e) {
39621       {
39622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39623       };
39624     } catch (std::exception& e) {
39625       {
39626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39627       };
39628     } catch (...) {
39629       {
39630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39631       };
39632     }
39633   }
39634   jresult = result;
39635   return jresult;
39636 }
39637
39638
39639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
39640   int jresult ;
39641   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39642   Dali::Pixel::Format result;
39643
39644   arg1 = (Dali::BufferImage *)jarg1;
39645   {
39646     try {
39647       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
39648     } catch (std::out_of_range& e) {
39649       {
39650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39651       };
39652     } catch (std::exception& e) {
39653       {
39654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39655       };
39656     } catch (...) {
39657       {
39658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39659       };
39660     }
39661   }
39662   jresult = (int)result;
39663   return jresult;
39664 }
39665
39666
39667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
39668   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39669
39670   arg1 = (Dali::BufferImage *)jarg1;
39671   {
39672     try {
39673       (arg1)->Update();
39674     } catch (std::out_of_range& e) {
39675       {
39676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39677       };
39678     } catch (std::exception& e) {
39679       {
39680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39681       };
39682     } catch (...) {
39683       {
39684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39685       };
39686     }
39687   }
39688 }
39689
39690
39691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
39692   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39693   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
39694   Dali::RectArea *argp2 ;
39695
39696   arg1 = (Dali::BufferImage *)jarg1;
39697   argp2 = (Dali::RectArea *)jarg2;
39698   if (!argp2) {
39699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
39700     return ;
39701   }
39702   arg2 = *argp2;
39703   {
39704     try {
39705       (arg1)->Update(arg2);
39706     } catch (std::out_of_range& e) {
39707       {
39708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39709       };
39710     } catch (std::exception& e) {
39711       {
39712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39713       };
39714     } catch (...) {
39715       {
39716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39717       };
39718     }
39719   }
39720 }
39721
39722
39723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
39724   unsigned int jresult ;
39725   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39726   bool result;
39727
39728   arg1 = (Dali::BufferImage *)jarg1;
39729   {
39730     try {
39731       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
39732     } catch (std::out_of_range& e) {
39733       {
39734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39735       };
39736     } catch (std::exception& e) {
39737       {
39738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39739       };
39740     } catch (...) {
39741       {
39742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39743       };
39744     }
39745   }
39746   jresult = result;
39747   return jresult;
39748 }
39749
39750
39751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
39752   void * jresult ;
39753   Dali::EncodedBufferImage *result = 0 ;
39754
39755   {
39756     try {
39757       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
39758     } catch (std::out_of_range& e) {
39759       {
39760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39761       };
39762     } catch (std::exception& e) {
39763       {
39764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39765       };
39766     } catch (...) {
39767       {
39768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39769       };
39770     }
39771   }
39772   jresult = (void *)result;
39773   return jresult;
39774 }
39775
39776
39777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
39778   void * jresult ;
39779   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39780   std::size_t arg2 ;
39781   Dali::EncodedBufferImage result;
39782
39783   arg1 = (uint8_t *)jarg1;
39784   arg2 = (std::size_t)jarg2;
39785   {
39786     try {
39787       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
39788     } catch (std::out_of_range& e) {
39789       {
39790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39791       };
39792     } catch (std::exception& e) {
39793       {
39794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39795       };
39796     } catch (...) {
39797       {
39798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39799       };
39800     }
39801   }
39802   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39803   return jresult;
39804 }
39805
39806
39807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
39808   void * jresult ;
39809   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39810   std::size_t arg2 ;
39811   Dali::ImageDimensions arg3 ;
39812   Dali::FittingMode::Type arg4 ;
39813   Dali::SamplingMode::Type arg5 ;
39814   bool arg6 ;
39815   Dali::ImageDimensions *argp3 ;
39816   Dali::EncodedBufferImage result;
39817
39818   arg1 = (uint8_t *)jarg1;
39819   arg2 = (std::size_t)jarg2;
39820   argp3 = (Dali::ImageDimensions *)jarg3;
39821   if (!argp3) {
39822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39823     return 0;
39824   }
39825   arg3 = *argp3;
39826   arg4 = (Dali::FittingMode::Type)jarg4;
39827   arg5 = (Dali::SamplingMode::Type)jarg5;
39828   arg6 = jarg6 ? true : false;
39829   {
39830     try {
39831       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
39832     } catch (std::out_of_range& e) {
39833       {
39834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39835       };
39836     } catch (std::exception& e) {
39837       {
39838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39839       };
39840     } catch (...) {
39841       {
39842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39843       };
39844     }
39845   }
39846   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39847   return jresult;
39848 }
39849
39850
39851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
39852   void * jresult ;
39853   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39854   std::size_t arg2 ;
39855   Dali::ImageDimensions arg3 ;
39856   Dali::FittingMode::Type arg4 ;
39857   Dali::SamplingMode::Type arg5 ;
39858   Dali::ImageDimensions *argp3 ;
39859   Dali::EncodedBufferImage result;
39860
39861   arg1 = (uint8_t *)jarg1;
39862   arg2 = (std::size_t)jarg2;
39863   argp3 = (Dali::ImageDimensions *)jarg3;
39864   if (!argp3) {
39865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39866     return 0;
39867   }
39868   arg3 = *argp3;
39869   arg4 = (Dali::FittingMode::Type)jarg4;
39870   arg5 = (Dali::SamplingMode::Type)jarg5;
39871   {
39872     try {
39873       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
39874     } catch (std::out_of_range& e) {
39875       {
39876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39877       };
39878     } catch (std::exception& e) {
39879       {
39880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39881       };
39882     } catch (...) {
39883       {
39884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39885       };
39886     }
39887   }
39888   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39889   return jresult;
39890 }
39891
39892
39893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
39894   void * jresult ;
39895   Dali::BaseHandle arg1 ;
39896   Dali::BaseHandle *argp1 ;
39897   Dali::EncodedBufferImage result;
39898
39899   argp1 = (Dali::BaseHandle *)jarg1;
39900   if (!argp1) {
39901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39902     return 0;
39903   }
39904   arg1 = *argp1;
39905   {
39906     try {
39907       result = Dali::EncodedBufferImage::DownCast(arg1);
39908     } catch (std::out_of_range& e) {
39909       {
39910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39911       };
39912     } catch (std::exception& e) {
39913       {
39914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39915       };
39916     } catch (...) {
39917       {
39918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39919       };
39920     }
39921   }
39922   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39923   return jresult;
39924 }
39925
39926
39927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
39928   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39929
39930   arg1 = (Dali::EncodedBufferImage *)jarg1;
39931   {
39932     try {
39933       delete arg1;
39934     } catch (std::out_of_range& e) {
39935       {
39936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39937       };
39938     } catch (std::exception& e) {
39939       {
39940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39941       };
39942     } catch (...) {
39943       {
39944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39945       };
39946     }
39947   }
39948 }
39949
39950
39951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
39952   void * jresult ;
39953   Dali::EncodedBufferImage *arg1 = 0 ;
39954   Dali::EncodedBufferImage *result = 0 ;
39955
39956   arg1 = (Dali::EncodedBufferImage *)jarg1;
39957   if (!arg1) {
39958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39959     return 0;
39960   }
39961   {
39962     try {
39963       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
39964     } catch (std::out_of_range& e) {
39965       {
39966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39967       };
39968     } catch (std::exception& e) {
39969       {
39970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39971       };
39972     } catch (...) {
39973       {
39974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39975       };
39976     }
39977   }
39978   jresult = (void *)result;
39979   return jresult;
39980 }
39981
39982
39983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
39984   void * jresult ;
39985   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39986   Dali::EncodedBufferImage *arg2 = 0 ;
39987   Dali::EncodedBufferImage *result = 0 ;
39988
39989   arg1 = (Dali::EncodedBufferImage *)jarg1;
39990   arg2 = (Dali::EncodedBufferImage *)jarg2;
39991   if (!arg2) {
39992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39993     return 0;
39994   }
39995   {
39996     try {
39997       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
39998     } catch (std::out_of_range& e) {
39999       {
40000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40001       };
40002     } catch (std::exception& e) {
40003       {
40004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40005       };
40006     } catch (...) {
40007       {
40008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40009       };
40010     }
40011   }
40012   jresult = (void *)result;
40013   return jresult;
40014 }
40015
40016
40017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
40018   void * jresult ;
40019   Dali::NativeImage *result = 0 ;
40020
40021   {
40022     try {
40023       result = (Dali::NativeImage *)new Dali::NativeImage();
40024     } catch (std::out_of_range& e) {
40025       {
40026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40027       };
40028     } catch (std::exception& e) {
40029       {
40030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40031       };
40032     } catch (...) {
40033       {
40034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40035       };
40036     }
40037   }
40038   jresult = (void *)result;
40039   return jresult;
40040 }
40041
40042
40043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
40044   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40045
40046   arg1 = (Dali::NativeImage *)jarg1;
40047   {
40048     try {
40049       delete arg1;
40050     } catch (std::out_of_range& e) {
40051       {
40052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40053       };
40054     } catch (std::exception& e) {
40055       {
40056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40057       };
40058     } catch (...) {
40059       {
40060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40061       };
40062     }
40063   }
40064 }
40065
40066
40067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
40068   void * jresult ;
40069   Dali::NativeImage *arg1 = 0 ;
40070   Dali::NativeImage *result = 0 ;
40071
40072   arg1 = (Dali::NativeImage *)jarg1;
40073   if (!arg1) {
40074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40075     return 0;
40076   }
40077   {
40078     try {
40079       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
40080     } catch (std::out_of_range& e) {
40081       {
40082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40083       };
40084     } catch (std::exception& e) {
40085       {
40086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40087       };
40088     } catch (...) {
40089       {
40090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40091       };
40092     }
40093   }
40094   jresult = (void *)result;
40095   return jresult;
40096 }
40097
40098
40099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
40100   void * jresult ;
40101   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40102   Dali::NativeImage *arg2 = 0 ;
40103   Dali::NativeImage *result = 0 ;
40104
40105   arg1 = (Dali::NativeImage *)jarg1;
40106   arg2 = (Dali::NativeImage *)jarg2;
40107   if (!arg2) {
40108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40109     return 0;
40110   }
40111   {
40112     try {
40113       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
40114     } catch (std::out_of_range& e) {
40115       {
40116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40117       };
40118     } catch (std::exception& e) {
40119       {
40120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40121       };
40122     } catch (...) {
40123       {
40124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40125       };
40126     }
40127   }
40128   jresult = (void *)result;
40129   return jresult;
40130 }
40131
40132
40133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
40134   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40135
40136   arg1 = (Dali::NativeImage *)jarg1;
40137   {
40138     try {
40139       (arg1)->CreateGlTexture();
40140     } catch (std::out_of_range& e) {
40141       {
40142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40143       };
40144     } catch (std::exception& e) {
40145       {
40146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40147       };
40148     } catch (...) {
40149       {
40150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40151       };
40152     }
40153   }
40154 }
40155
40156
40157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
40158   void * jresult ;
40159   NativeImageInterface *arg1 = 0 ;
40160   Dali::NativeImage result;
40161
40162   arg1 = (NativeImageInterface *)jarg1;
40163   if (!arg1) {
40164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
40165     return 0;
40166   }
40167   {
40168     try {
40169       result = Dali::NativeImage::New(*arg1);
40170     } catch (std::out_of_range& e) {
40171       {
40172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40173       };
40174     } catch (std::exception& e) {
40175       {
40176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40177       };
40178     } catch (...) {
40179       {
40180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40181       };
40182     }
40183   }
40184   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40185   return jresult;
40186 }
40187
40188
40189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
40190   void * jresult ;
40191   Dali::BaseHandle arg1 ;
40192   Dali::BaseHandle *argp1 ;
40193   Dali::NativeImage result;
40194
40195   argp1 = (Dali::BaseHandle *)jarg1;
40196   if (!argp1) {
40197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40198     return 0;
40199   }
40200   arg1 = *argp1;
40201   {
40202     try {
40203       result = Dali::NativeImage::DownCast(arg1);
40204     } catch (std::out_of_range& e) {
40205       {
40206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40207       };
40208     } catch (std::exception& e) {
40209       {
40210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40211       };
40212     } catch (...) {
40213       {
40214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40215       };
40216     }
40217   }
40218   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40219   return jresult;
40220 }
40221
40222
40223 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
40224   char * jresult ;
40225   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40226   char *result = 0 ;
40227
40228   arg1 = (Dali::NativeImage *)jarg1;
40229   {
40230     try {
40231       result = (char *)(arg1)->GetCustomFragmentPreFix();
40232     } catch (std::out_of_range& e) {
40233       {
40234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40235       };
40236     } catch (std::exception& e) {
40237       {
40238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40239       };
40240     } catch (...) {
40241       {
40242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40243       };
40244     }
40245   }
40246   jresult = SWIG_csharp_string_callback((const char *)result);
40247   return jresult;
40248 }
40249
40250
40251 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
40252   char * jresult ;
40253   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40254   char *result = 0 ;
40255
40256   arg1 = (Dali::NativeImage *)jarg1;
40257   {
40258     try {
40259       result = (char *)(arg1)->GetCustomSamplerTypename();
40260     } catch (std::out_of_range& e) {
40261       {
40262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40263       };
40264     } catch (std::exception& e) {
40265       {
40266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40267       };
40268     } catch (...) {
40269       {
40270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40271       };
40272     }
40273   }
40274   jresult = SWIG_csharp_string_callback((const char *)result);
40275   return jresult;
40276 }
40277
40278
40279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
40280   unsigned int jresult ;
40281   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40282   bool result;
40283
40284   arg1 = (Dali::NativeImageInterface *)jarg1;
40285   {
40286     try {
40287       result = (bool)(arg1)->GlExtensionCreate();
40288     } catch (std::out_of_range& e) {
40289       {
40290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40291       };
40292     } catch (std::exception& e) {
40293       {
40294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40295       };
40296     } catch (...) {
40297       {
40298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40299       };
40300     }
40301   }
40302   jresult = result;
40303   return jresult;
40304 }
40305
40306
40307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
40308   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40309
40310   arg1 = (Dali::NativeImageInterface *)jarg1;
40311   {
40312     try {
40313       (arg1)->GlExtensionDestroy();
40314     } catch (std::out_of_range& e) {
40315       {
40316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40317       };
40318     } catch (std::exception& e) {
40319       {
40320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40321       };
40322     } catch (...) {
40323       {
40324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40325       };
40326     }
40327   }
40328 }
40329
40330
40331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
40332   unsigned int jresult ;
40333   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40334   unsigned int result;
40335
40336   arg1 = (Dali::NativeImageInterface *)jarg1;
40337   {
40338     try {
40339       result = (unsigned int)(arg1)->TargetTexture();
40340     } catch (std::out_of_range& e) {
40341       {
40342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40343       };
40344     } catch (std::exception& e) {
40345       {
40346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40347       };
40348     } catch (...) {
40349       {
40350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40351       };
40352     }
40353   }
40354   jresult = result;
40355   return jresult;
40356 }
40357
40358
40359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
40360   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40361
40362   arg1 = (Dali::NativeImageInterface *)jarg1;
40363   {
40364     try {
40365       (arg1)->PrepareTexture();
40366     } catch (std::out_of_range& e) {
40367       {
40368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40369       };
40370     } catch (std::exception& e) {
40371       {
40372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40373       };
40374     } catch (...) {
40375       {
40376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40377       };
40378     }
40379   }
40380 }
40381
40382
40383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
40384   unsigned int jresult ;
40385   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40386   unsigned int result;
40387
40388   arg1 = (Dali::NativeImageInterface *)jarg1;
40389   {
40390     try {
40391       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
40392     } catch (std::out_of_range& e) {
40393       {
40394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40395       };
40396     } catch (std::exception& e) {
40397       {
40398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40399       };
40400     } catch (...) {
40401       {
40402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40403       };
40404     }
40405   }
40406   jresult = result;
40407   return jresult;
40408 }
40409
40410
40411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
40412   unsigned int jresult ;
40413   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40414   unsigned int result;
40415
40416   arg1 = (Dali::NativeImageInterface *)jarg1;
40417   {
40418     try {
40419       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
40420     } catch (std::out_of_range& e) {
40421       {
40422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40423       };
40424     } catch (std::exception& e) {
40425       {
40426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40427       };
40428     } catch (...) {
40429       {
40430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40431       };
40432     }
40433   }
40434   jresult = result;
40435   return jresult;
40436 }
40437
40438
40439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
40440   unsigned int jresult ;
40441   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40442   bool result;
40443
40444   arg1 = (Dali::NativeImageInterface *)jarg1;
40445   {
40446     try {
40447       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
40448     } catch (std::out_of_range& e) {
40449       {
40450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40451       };
40452     } catch (std::exception& e) {
40453       {
40454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40455       };
40456     } catch (...) {
40457       {
40458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40459       };
40460     }
40461   }
40462   jresult = result;
40463   return jresult;
40464 }
40465
40466
40467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
40468   void * jresult ;
40469   std::string *arg1 = 0 ;
40470   Dali::ImageDimensions result;
40471
40472   if (!jarg1) {
40473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40474     return 0;
40475   }
40476   std::string arg1_str(jarg1);
40477   arg1 = &arg1_str;
40478   {
40479     try {
40480       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
40481     } catch (std::out_of_range& e) {
40482       {
40483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40484       };
40485     } catch (std::exception& e) {
40486       {
40487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40488       };
40489     } catch (...) {
40490       {
40491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40492       };
40493     }
40494   }
40495   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
40496
40497   //argout typemap for const std::string&
40498
40499   return jresult;
40500 }
40501
40502
40503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
40504   void * jresult ;
40505   Dali::ResourceImage *result = 0 ;
40506
40507   {
40508     try {
40509       result = (Dali::ResourceImage *)new Dali::ResourceImage();
40510     } catch (std::out_of_range& e) {
40511       {
40512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40513       };
40514     } catch (std::exception& e) {
40515       {
40516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40517       };
40518     } catch (...) {
40519       {
40520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40521       };
40522     }
40523   }
40524   jresult = (void *)result;
40525   return jresult;
40526 }
40527
40528
40529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
40530   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40531
40532   arg1 = (Dali::ResourceImage *)jarg1;
40533   {
40534     try {
40535       delete arg1;
40536     } catch (std::out_of_range& e) {
40537       {
40538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40539       };
40540     } catch (std::exception& e) {
40541       {
40542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40543       };
40544     } catch (...) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40547       };
40548     }
40549   }
40550 }
40551
40552
40553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
40554   void * jresult ;
40555   Dali::ResourceImage *arg1 = 0 ;
40556   Dali::ResourceImage *result = 0 ;
40557
40558   arg1 = (Dali::ResourceImage *)jarg1;
40559   if (!arg1) {
40560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40561     return 0;
40562   }
40563   {
40564     try {
40565       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
40566     } catch (std::out_of_range& e) {
40567       {
40568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40569       };
40570     } catch (std::exception& e) {
40571       {
40572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40573       };
40574     } catch (...) {
40575       {
40576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40577       };
40578     }
40579   }
40580   jresult = (void *)result;
40581   return jresult;
40582 }
40583
40584
40585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
40586   void * jresult ;
40587   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40588   Dali::ResourceImage *arg2 = 0 ;
40589   Dali::ResourceImage *result = 0 ;
40590
40591   arg1 = (Dali::ResourceImage *)jarg1;
40592   arg2 = (Dali::ResourceImage *)jarg2;
40593   if (!arg2) {
40594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40595     return 0;
40596   }
40597   {
40598     try {
40599       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
40600     } catch (std::out_of_range& e) {
40601       {
40602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40603       };
40604     } catch (std::exception& e) {
40605       {
40606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40607       };
40608     } catch (...) {
40609       {
40610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40611       };
40612     }
40613   }
40614   jresult = (void *)result;
40615   return jresult;
40616 }
40617
40618
40619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
40620   void * jresult ;
40621   std::string *arg1 = 0 ;
40622   bool arg2 ;
40623   Dali::ResourceImage result;
40624
40625   if (!jarg1) {
40626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40627     return 0;
40628   }
40629   std::string arg1_str(jarg1);
40630   arg1 = &arg1_str;
40631   arg2 = jarg2 ? true : false;
40632   {
40633     try {
40634       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40635     } catch (std::out_of_range& e) {
40636       {
40637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40638       };
40639     } catch (std::exception& e) {
40640       {
40641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40642       };
40643     } catch (...) {
40644       {
40645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40646       };
40647     }
40648   }
40649   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40650
40651   //argout typemap for const std::string&
40652
40653   return jresult;
40654 }
40655
40656
40657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
40658   void * jresult ;
40659   std::string *arg1 = 0 ;
40660   Dali::ResourceImage result;
40661
40662   if (!jarg1) {
40663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40664     return 0;
40665   }
40666   std::string arg1_str(jarg1);
40667   arg1 = &arg1_str;
40668   {
40669     try {
40670       result = Dali::ResourceImage::New((std::string const &)*arg1);
40671     } catch (std::out_of_range& e) {
40672       {
40673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40674       };
40675     } catch (std::exception& e) {
40676       {
40677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40678       };
40679     } catch (...) {
40680       {
40681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40682       };
40683     }
40684   }
40685   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40686
40687   //argout typemap for const std::string&
40688
40689   return jresult;
40690 }
40691
40692
40693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
40694   void * jresult ;
40695   std::string *arg1 = 0 ;
40696   Dali::ImageDimensions arg2 ;
40697   Dali::FittingMode::Type arg3 ;
40698   Dali::SamplingMode::Type arg4 ;
40699   bool arg5 ;
40700   Dali::ImageDimensions *argp2 ;
40701   Dali::ResourceImage result;
40702
40703   if (!jarg1) {
40704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40705     return 0;
40706   }
40707   std::string arg1_str(jarg1);
40708   arg1 = &arg1_str;
40709   argp2 = (Dali::ImageDimensions *)jarg2;
40710   if (!argp2) {
40711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40712     return 0;
40713   }
40714   arg2 = *argp2;
40715   arg3 = (Dali::FittingMode::Type)jarg3;
40716   arg4 = (Dali::SamplingMode::Type)jarg4;
40717   arg5 = jarg5 ? true : false;
40718   {
40719     try {
40720       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
40721     } catch (std::out_of_range& e) {
40722       {
40723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40724       };
40725     } catch (std::exception& e) {
40726       {
40727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40728       };
40729     } catch (...) {
40730       {
40731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40732       };
40733     }
40734   }
40735   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40736
40737   //argout typemap for const std::string&
40738
40739   return jresult;
40740 }
40741
40742
40743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
40744   void * jresult ;
40745   std::string *arg1 = 0 ;
40746   Dali::ImageDimensions arg2 ;
40747   Dali::FittingMode::Type arg3 ;
40748   Dali::SamplingMode::Type arg4 ;
40749   Dali::ImageDimensions *argp2 ;
40750   Dali::ResourceImage result;
40751
40752   if (!jarg1) {
40753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40754     return 0;
40755   }
40756   std::string arg1_str(jarg1);
40757   arg1 = &arg1_str;
40758   argp2 = (Dali::ImageDimensions *)jarg2;
40759   if (!argp2) {
40760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40761     return 0;
40762   }
40763   arg2 = *argp2;
40764   arg3 = (Dali::FittingMode::Type)jarg3;
40765   arg4 = (Dali::SamplingMode::Type)jarg4;
40766   {
40767     try {
40768       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
40769     } catch (std::out_of_range& e) {
40770       {
40771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40772       };
40773     } catch (std::exception& e) {
40774       {
40775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40776       };
40777     } catch (...) {
40778       {
40779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40780       };
40781     }
40782   }
40783   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40784
40785   //argout typemap for const std::string&
40786
40787   return jresult;
40788 }
40789
40790
40791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
40792   void * jresult ;
40793   std::string *arg1 = 0 ;
40794   Dali::ImageDimensions arg2 ;
40795   Dali::FittingMode::Type arg3 ;
40796   Dali::ImageDimensions *argp2 ;
40797   Dali::ResourceImage result;
40798
40799   if (!jarg1) {
40800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40801     return 0;
40802   }
40803   std::string arg1_str(jarg1);
40804   arg1 = &arg1_str;
40805   argp2 = (Dali::ImageDimensions *)jarg2;
40806   if (!argp2) {
40807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40808     return 0;
40809   }
40810   arg2 = *argp2;
40811   arg3 = (Dali::FittingMode::Type)jarg3;
40812   {
40813     try {
40814       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
40815     } catch (std::out_of_range& e) {
40816       {
40817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40818       };
40819     } catch (std::exception& e) {
40820       {
40821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40822       };
40823     } catch (...) {
40824       {
40825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40826       };
40827     }
40828   }
40829   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40830
40831   //argout typemap for const std::string&
40832
40833   return jresult;
40834 }
40835
40836
40837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
40838   void * jresult ;
40839   std::string *arg1 = 0 ;
40840   Dali::ImageDimensions arg2 ;
40841   Dali::ImageDimensions *argp2 ;
40842   Dali::ResourceImage result;
40843
40844   if (!jarg1) {
40845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40846     return 0;
40847   }
40848   std::string arg1_str(jarg1);
40849   arg1 = &arg1_str;
40850   argp2 = (Dali::ImageDimensions *)jarg2;
40851   if (!argp2) {
40852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40853     return 0;
40854   }
40855   arg2 = *argp2;
40856   {
40857     try {
40858       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40859     } catch (std::out_of_range& e) {
40860       {
40861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40862       };
40863     } catch (std::exception& e) {
40864       {
40865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40866       };
40867     } catch (...) {
40868       {
40869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40870       };
40871     }
40872   }
40873   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40874
40875   //argout typemap for const std::string&
40876
40877   return jresult;
40878 }
40879
40880
40881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
40882   void * jresult ;
40883   Dali::BaseHandle arg1 ;
40884   Dali::BaseHandle *argp1 ;
40885   Dali::ResourceImage result;
40886
40887   argp1 = (Dali::BaseHandle *)jarg1;
40888   if (!argp1) {
40889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40890     return 0;
40891   }
40892   arg1 = *argp1;
40893   {
40894     try {
40895       result = Dali::ResourceImage::DownCast(arg1);
40896     } catch (std::out_of_range& e) {
40897       {
40898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40899       };
40900     } catch (std::exception& e) {
40901       {
40902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40903       };
40904     } catch (...) {
40905       {
40906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40907       };
40908     }
40909   }
40910   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40911   return jresult;
40912 }
40913
40914
40915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
40916   int jresult ;
40917   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40918   Dali::LoadingState result;
40919
40920   arg1 = (Dali::ResourceImage *)jarg1;
40921   {
40922     try {
40923       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
40924     } catch (std::out_of_range& e) {
40925       {
40926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40927       };
40928     } catch (std::exception& e) {
40929       {
40930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40931       };
40932     } catch (...) {
40933       {
40934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40935       };
40936     }
40937   }
40938   jresult = (int)result;
40939   return jresult;
40940 }
40941
40942
40943 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
40944   char * jresult ;
40945   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40946   std::string result;
40947
40948   arg1 = (Dali::ResourceImage *)jarg1;
40949   {
40950     try {
40951       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
40952     } catch (std::out_of_range& e) {
40953       {
40954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40955       };
40956     } catch (std::exception& e) {
40957       {
40958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40959       };
40960     } catch (...) {
40961       {
40962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40963       };
40964     }
40965   }
40966   jresult = SWIG_csharp_string_callback((&result)->c_str());
40967   return jresult;
40968 }
40969
40970
40971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
40972   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40973
40974   arg1 = (Dali::ResourceImage *)jarg1;
40975   {
40976     try {
40977       (arg1)->Reload();
40978     } catch (std::out_of_range& e) {
40979       {
40980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40981       };
40982     } catch (std::exception& e) {
40983       {
40984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40985       };
40986     } catch (...) {
40987       {
40988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40989       };
40990     }
40991   }
40992 }
40993
40994
40995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
40996   void * jresult ;
40997   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40998   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
40999
41000   arg1 = (Dali::ResourceImage *)jarg1;
41001   {
41002     try {
41003       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
41004     } catch (std::out_of_range& e) {
41005       {
41006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41007       };
41008     } catch (std::exception& e) {
41009       {
41010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41011       };
41012     } catch (...) {
41013       {
41014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41015       };
41016     }
41017   }
41018   jresult = (void *)result;
41019   return jresult;
41020 }
41021
41022
41023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
41024   void * jresult ;
41025   Dali::FrameBufferImage *result = 0 ;
41026
41027   {
41028     try {
41029       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
41030     } catch (std::out_of_range& e) {
41031       {
41032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41033       };
41034     } catch (std::exception& e) {
41035       {
41036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41037       };
41038     } catch (...) {
41039       {
41040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41041       };
41042     }
41043   }
41044   jresult = (void *)result;
41045   return jresult;
41046 }
41047
41048
41049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
41050   void * jresult ;
41051   unsigned int arg1 ;
41052   unsigned int arg2 ;
41053   Dali::Pixel::Format arg3 ;
41054   Dali::RenderBuffer::Format arg4 ;
41055   Dali::FrameBufferImage result;
41056
41057   arg1 = (unsigned int)jarg1;
41058   arg2 = (unsigned int)jarg2;
41059   arg3 = (Dali::Pixel::Format)jarg3;
41060   arg4 = (Dali::RenderBuffer::Format)jarg4;
41061   {
41062     try {
41063       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
41064     } catch (std::out_of_range& e) {
41065       {
41066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41067       };
41068     } catch (std::exception& e) {
41069       {
41070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41071       };
41072     } catch (...) {
41073       {
41074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41075       };
41076     }
41077   }
41078   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41079   return jresult;
41080 }
41081
41082
41083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41084   void * jresult ;
41085   unsigned int arg1 ;
41086   unsigned int arg2 ;
41087   Dali::Pixel::Format arg3 ;
41088   Dali::FrameBufferImage result;
41089
41090   arg1 = (unsigned int)jarg1;
41091   arg2 = (unsigned int)jarg2;
41092   arg3 = (Dali::Pixel::Format)jarg3;
41093   {
41094     try {
41095       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
41096     } catch (std::out_of_range& e) {
41097       {
41098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41099       };
41100     } catch (std::exception& e) {
41101       {
41102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41103       };
41104     } catch (...) {
41105       {
41106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41107       };
41108     }
41109   }
41110   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41111   return jresult;
41112 }
41113
41114
41115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
41116   void * jresult ;
41117   unsigned int arg1 ;
41118   unsigned int arg2 ;
41119   Dali::FrameBufferImage result;
41120
41121   arg1 = (unsigned int)jarg1;
41122   arg2 = (unsigned int)jarg2;
41123   {
41124     try {
41125       result = Dali::FrameBufferImage::New(arg1,arg2);
41126     } catch (std::out_of_range& e) {
41127       {
41128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41129       };
41130     } catch (std::exception& e) {
41131       {
41132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41133       };
41134     } catch (...) {
41135       {
41136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41137       };
41138     }
41139   }
41140   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41141   return jresult;
41142 }
41143
41144
41145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
41146   void * jresult ;
41147   unsigned int arg1 ;
41148   Dali::FrameBufferImage result;
41149
41150   arg1 = (unsigned int)jarg1;
41151   {
41152     try {
41153       result = Dali::FrameBufferImage::New(arg1);
41154     } catch (std::out_of_range& e) {
41155       {
41156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41157       };
41158     } catch (std::exception& e) {
41159       {
41160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41161       };
41162     } catch (...) {
41163       {
41164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41165       };
41166     }
41167   }
41168   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41169   return jresult;
41170 }
41171
41172
41173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
41174   void * jresult ;
41175   Dali::FrameBufferImage result;
41176
41177   {
41178     try {
41179       result = Dali::FrameBufferImage::New();
41180     } catch (std::out_of_range& e) {
41181       {
41182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41183       };
41184     } catch (std::exception& e) {
41185       {
41186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41187       };
41188     } catch (...) {
41189       {
41190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41191       };
41192     }
41193   }
41194   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41195   return jresult;
41196 }
41197
41198
41199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
41200   void * jresult ;
41201   Dali::NativeImageInterface *arg1 = 0 ;
41202   Dali::FrameBufferImage result;
41203
41204   arg1 = (Dali::NativeImageInterface *)jarg1;
41205   if (!arg1) {
41206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
41207     return 0;
41208   }
41209   {
41210     try {
41211       result = Dali::FrameBufferImage::New(*arg1);
41212     } catch (std::out_of_range& e) {
41213       {
41214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41215       };
41216     } catch (std::exception& e) {
41217       {
41218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41219       };
41220     } catch (...) {
41221       {
41222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41223       };
41224     }
41225   }
41226   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41227   return jresult;
41228 }
41229
41230
41231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
41232   void * jresult ;
41233   Dali::BaseHandle arg1 ;
41234   Dali::BaseHandle *argp1 ;
41235   Dali::FrameBufferImage result;
41236
41237   argp1 = (Dali::BaseHandle *)jarg1;
41238   if (!argp1) {
41239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41240     return 0;
41241   }
41242   arg1 = *argp1;
41243   {
41244     try {
41245       result = Dali::FrameBufferImage::DownCast(arg1);
41246     } catch (std::out_of_range& e) {
41247       {
41248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41249       };
41250     } catch (std::exception& e) {
41251       {
41252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41253       };
41254     } catch (...) {
41255       {
41256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41257       };
41258     }
41259   }
41260   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41261   return jresult;
41262 }
41263
41264
41265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
41266   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41267
41268   arg1 = (Dali::FrameBufferImage *)jarg1;
41269   {
41270     try {
41271       delete arg1;
41272     } catch (std::out_of_range& e) {
41273       {
41274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41275       };
41276     } catch (std::exception& e) {
41277       {
41278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41279       };
41280     } catch (...) {
41281       {
41282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41283       };
41284     }
41285   }
41286 }
41287
41288
41289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
41290   void * jresult ;
41291   Dali::FrameBufferImage *arg1 = 0 ;
41292   Dali::FrameBufferImage *result = 0 ;
41293
41294   arg1 = (Dali::FrameBufferImage *)jarg1;
41295   if (!arg1) {
41296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41297     return 0;
41298   }
41299   {
41300     try {
41301       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
41302     } catch (std::out_of_range& e) {
41303       {
41304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41305       };
41306     } catch (std::exception& e) {
41307       {
41308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41309       };
41310     } catch (...) {
41311       {
41312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41313       };
41314     }
41315   }
41316   jresult = (void *)result;
41317   return jresult;
41318 }
41319
41320
41321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
41322   void * jresult ;
41323   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41324   Dali::FrameBufferImage *arg2 = 0 ;
41325   Dali::FrameBufferImage *result = 0 ;
41326
41327   arg1 = (Dali::FrameBufferImage *)jarg1;
41328   arg2 = (Dali::FrameBufferImage *)jarg2;
41329   if (!arg2) {
41330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41331     return 0;
41332   }
41333   {
41334     try {
41335       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
41336     } catch (std::out_of_range& e) {
41337       {
41338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41339       };
41340     } catch (std::exception& e) {
41341       {
41342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41343       };
41344     } catch (...) {
41345       {
41346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41347       };
41348     }
41349   }
41350   jresult = (void *)result;
41351   return jresult;
41352 }
41353
41354
41355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
41356   void * jresult ;
41357   Dali::NinePatchImage *result = 0 ;
41358
41359   {
41360     try {
41361       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
41362     } catch (std::out_of_range& e) {
41363       {
41364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41365       };
41366     } catch (std::exception& e) {
41367       {
41368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41369       };
41370     } catch (...) {
41371       {
41372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41373       };
41374     }
41375   }
41376   jresult = (void *)result;
41377   return jresult;
41378 }
41379
41380
41381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
41382   void * jresult ;
41383   std::string *arg1 = 0 ;
41384   Dali::NinePatchImage result;
41385
41386   if (!jarg1) {
41387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41388     return 0;
41389   }
41390   std::string arg1_str(jarg1);
41391   arg1 = &arg1_str;
41392   {
41393     try {
41394       result = Dali::NinePatchImage::New((std::string const &)*arg1);
41395     } catch (std::out_of_range& e) {
41396       {
41397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41398       };
41399     } catch (std::exception& e) {
41400       {
41401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41402       };
41403     } catch (...) {
41404       {
41405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41406       };
41407     }
41408   }
41409   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41410
41411   //argout typemap for const std::string&
41412
41413   return jresult;
41414 }
41415
41416
41417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
41418   void * jresult ;
41419   Dali::BaseHandle arg1 ;
41420   Dali::BaseHandle *argp1 ;
41421   Dali::NinePatchImage result;
41422
41423   argp1 = (Dali::BaseHandle *)jarg1;
41424   if (!argp1) {
41425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41426     return 0;
41427   }
41428   arg1 = *argp1;
41429   {
41430     try {
41431       result = Dali::NinePatchImage::DownCast(arg1);
41432     } catch (std::out_of_range& e) {
41433       {
41434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41435       };
41436     } catch (std::exception& e) {
41437       {
41438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41439       };
41440     } catch (...) {
41441       {
41442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41443       };
41444     }
41445   }
41446   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41447   return jresult;
41448 }
41449
41450
41451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
41452   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41453
41454   arg1 = (Dali::NinePatchImage *)jarg1;
41455   {
41456     try {
41457       delete arg1;
41458     } catch (std::out_of_range& e) {
41459       {
41460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41461       };
41462     } catch (std::exception& e) {
41463       {
41464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41465       };
41466     } catch (...) {
41467       {
41468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41469       };
41470     }
41471   }
41472 }
41473
41474
41475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
41476   void * jresult ;
41477   Dali::NinePatchImage *arg1 = 0 ;
41478   Dali::NinePatchImage *result = 0 ;
41479
41480   arg1 = (Dali::NinePatchImage *)jarg1;
41481   if (!arg1) {
41482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41483     return 0;
41484   }
41485   {
41486     try {
41487       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
41488     } catch (std::out_of_range& e) {
41489       {
41490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41491       };
41492     } catch (std::exception& e) {
41493       {
41494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41495       };
41496     } catch (...) {
41497       {
41498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41499       };
41500     }
41501   }
41502   jresult = (void *)result;
41503   return jresult;
41504 }
41505
41506
41507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
41508   void * jresult ;
41509   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41510   Dali::NinePatchImage *arg2 = 0 ;
41511   Dali::NinePatchImage *result = 0 ;
41512
41513   arg1 = (Dali::NinePatchImage *)jarg1;
41514   arg2 = (Dali::NinePatchImage *)jarg2;
41515   if (!arg2) {
41516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41517     return 0;
41518   }
41519   {
41520     try {
41521       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
41522     } catch (std::out_of_range& e) {
41523       {
41524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41525       };
41526     } catch (std::exception& e) {
41527       {
41528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41529       };
41530     } catch (...) {
41531       {
41532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41533       };
41534     }
41535   }
41536   jresult = (void *)result;
41537   return jresult;
41538 }
41539
41540
41541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
41542   void * jresult ;
41543   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41544   Dali::Vector4 result;
41545
41546   arg1 = (Dali::NinePatchImage *)jarg1;
41547   {
41548     try {
41549       result = (arg1)->GetStretchBorders();
41550     } catch (std::out_of_range& e) {
41551       {
41552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41553       };
41554     } catch (std::exception& e) {
41555       {
41556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41557       };
41558     } catch (...) {
41559       {
41560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41561       };
41562     }
41563   }
41564   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41565   return jresult;
41566 }
41567
41568
41569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
41570   void * jresult ;
41571   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41572   Dali::NinePatchImage::StretchRanges *result = 0 ;
41573
41574   arg1 = (Dali::NinePatchImage *)jarg1;
41575   {
41576     try {
41577       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
41578     } catch (std::out_of_range& e) {
41579       {
41580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41581       };
41582     } catch (std::exception& e) {
41583       {
41584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41585       };
41586     } catch (...) {
41587       {
41588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41589       };
41590     }
41591   }
41592   jresult = (void *)result;
41593   return jresult;
41594 }
41595
41596
41597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
41598   void * jresult ;
41599   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41600   Dali::NinePatchImage::StretchRanges *result = 0 ;
41601
41602   arg1 = (Dali::NinePatchImage *)jarg1;
41603   {
41604     try {
41605       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
41606     } catch (std::out_of_range& e) {
41607       {
41608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41609       };
41610     } catch (std::exception& e) {
41611       {
41612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41613       };
41614     } catch (...) {
41615       {
41616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41617       };
41618     }
41619   }
41620   jresult = (void *)result;
41621   return jresult;
41622 }
41623
41624
41625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
41626   void * jresult ;
41627   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41628   Dali::Rect< int > result;
41629
41630   arg1 = (Dali::NinePatchImage *)jarg1;
41631   {
41632     try {
41633       result = (arg1)->GetChildRectangle();
41634     } catch (std::out_of_range& e) {
41635       {
41636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41637       };
41638     } catch (std::exception& e) {
41639       {
41640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41641       };
41642     } catch (...) {
41643       {
41644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41645       };
41646     }
41647   }
41648   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
41649   return jresult;
41650 }
41651
41652
41653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
41654   void * jresult ;
41655   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41656   Dali::BufferImage result;
41657
41658   arg1 = (Dali::NinePatchImage *)jarg1;
41659   {
41660     try {
41661       result = (arg1)->CreateCroppedBufferImage();
41662     } catch (std::out_of_range& e) {
41663       {
41664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41665       };
41666     } catch (std::exception& e) {
41667       {
41668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41669       };
41670     } catch (...) {
41671       {
41672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41673       };
41674     }
41675   }
41676   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41677   return jresult;
41678 }
41679
41680
41681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
41682   unsigned int jresult ;
41683   std::string *arg1 = 0 ;
41684   bool result;
41685
41686   if (!jarg1) {
41687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41688     return 0;
41689   }
41690   std::string arg1_str(jarg1);
41691   arg1 = &arg1_str;
41692   {
41693     try {
41694       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
41695     } catch (std::out_of_range& e) {
41696       {
41697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41698       };
41699     } catch (std::exception& e) {
41700       {
41701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41702       };
41703     } catch (...) {
41704       {
41705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41706       };
41707     }
41708   }
41709   jresult = result;
41710
41711   //argout typemap for const std::string&
41712
41713   return jresult;
41714 }
41715
41716
41717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
41718   int jresult ;
41719   int result;
41720
41721   result = (int)Dali::CameraActor::Property::TYPE;
41722   jresult = (int)result;
41723   return jresult;
41724 }
41725
41726
41727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
41728   int jresult ;
41729   int result;
41730
41731   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
41732   jresult = (int)result;
41733   return jresult;
41734 }
41735
41736
41737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
41738   int jresult ;
41739   int result;
41740
41741   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
41742   jresult = (int)result;
41743   return jresult;
41744 }
41745
41746
41747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
41748   int jresult ;
41749   int result;
41750
41751   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
41752   jresult = (int)result;
41753   return jresult;
41754 }
41755
41756
41757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
41758   int jresult ;
41759   int result;
41760
41761   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
41762   jresult = (int)result;
41763   return jresult;
41764 }
41765
41766
41767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
41768   int jresult ;
41769   int result;
41770
41771   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
41772   jresult = (int)result;
41773   return jresult;
41774 }
41775
41776
41777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
41778   int jresult ;
41779   int result;
41780
41781   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
41782   jresult = (int)result;
41783   return jresult;
41784 }
41785
41786
41787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
41788   int jresult ;
41789   int result;
41790
41791   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
41792   jresult = (int)result;
41793   return jresult;
41794 }
41795
41796
41797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
41798   int jresult ;
41799   int result;
41800
41801   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
41802   jresult = (int)result;
41803   return jresult;
41804 }
41805
41806
41807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
41808   int jresult ;
41809   int result;
41810
41811   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
41812   jresult = (int)result;
41813   return jresult;
41814 }
41815
41816
41817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
41818   int jresult ;
41819   int result;
41820
41821   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
41822   jresult = (int)result;
41823   return jresult;
41824 }
41825
41826
41827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
41828   int jresult ;
41829   int result;
41830
41831   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
41832   jresult = (int)result;
41833   return jresult;
41834 }
41835
41836
41837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
41838   int jresult ;
41839   int result;
41840
41841   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
41842   jresult = (int)result;
41843   return jresult;
41844 }
41845
41846
41847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
41848   int jresult ;
41849   int result;
41850
41851   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
41852   jresult = (int)result;
41853   return jresult;
41854 }
41855
41856
41857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
41858   void * jresult ;
41859   Dali::CameraActor::Property *result = 0 ;
41860
41861   {
41862     try {
41863       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
41864     } catch (std::out_of_range& e) {
41865       {
41866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41867       };
41868     } catch (std::exception& e) {
41869       {
41870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41871       };
41872     } catch (...) {
41873       {
41874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41875       };
41876     }
41877   }
41878   jresult = (void *)result;
41879   return jresult;
41880 }
41881
41882
41883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
41884   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
41885
41886   arg1 = (Dali::CameraActor::Property *)jarg1;
41887   {
41888     try {
41889       delete arg1;
41890     } catch (std::out_of_range& e) {
41891       {
41892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41893       };
41894     } catch (std::exception& e) {
41895       {
41896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41897       };
41898     } catch (...) {
41899       {
41900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41901       };
41902     }
41903   }
41904 }
41905
41906
41907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
41908   void * jresult ;
41909   Dali::CameraActor *result = 0 ;
41910
41911   {
41912     try {
41913       result = (Dali::CameraActor *)new Dali::CameraActor();
41914     } catch (std::out_of_range& e) {
41915       {
41916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41917       };
41918     } catch (std::exception& e) {
41919       {
41920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41921       };
41922     } catch (...) {
41923       {
41924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41925       };
41926     }
41927   }
41928   jresult = (void *)result;
41929   return jresult;
41930 }
41931
41932
41933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
41934   void * jresult ;
41935   Dali::CameraActor result;
41936
41937   {
41938     try {
41939       result = Dali::CameraActor::New();
41940     } catch (std::out_of_range& e) {
41941       {
41942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41943       };
41944     } catch (std::exception& e) {
41945       {
41946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41947       };
41948     } catch (...) {
41949       {
41950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41951       };
41952     }
41953   }
41954   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41955   return jresult;
41956 }
41957
41958
41959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
41960   void * jresult ;
41961   Dali::Size *arg1 = 0 ;
41962   Dali::CameraActor result;
41963
41964   arg1 = (Dali::Size *)jarg1;
41965   if (!arg1) {
41966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
41967     return 0;
41968   }
41969   {
41970     try {
41971       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
41972     } catch (std::out_of_range& e) {
41973       {
41974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41975       };
41976     } catch (std::exception& e) {
41977       {
41978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41979       };
41980     } catch (...) {
41981       {
41982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41983       };
41984     }
41985   }
41986   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41987   return jresult;
41988 }
41989
41990
41991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
41992   void * jresult ;
41993   Dali::BaseHandle arg1 ;
41994   Dali::BaseHandle *argp1 ;
41995   Dali::CameraActor result;
41996
41997   argp1 = (Dali::BaseHandle *)jarg1;
41998   if (!argp1) {
41999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42000     return 0;
42001   }
42002   arg1 = *argp1;
42003   {
42004     try {
42005       result = Dali::CameraActor::DownCast(arg1);
42006     } catch (std::out_of_range& e) {
42007       {
42008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42009       };
42010     } catch (std::exception& e) {
42011       {
42012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42013       };
42014     } catch (...) {
42015       {
42016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42017       };
42018     }
42019   }
42020   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
42021   return jresult;
42022 }
42023
42024
42025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
42026   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42027
42028   arg1 = (Dali::CameraActor *)jarg1;
42029   {
42030     try {
42031       delete arg1;
42032     } catch (std::out_of_range& e) {
42033       {
42034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42035       };
42036     } catch (std::exception& e) {
42037       {
42038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42039       };
42040     } catch (...) {
42041       {
42042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42043       };
42044     }
42045   }
42046 }
42047
42048
42049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
42050   void * jresult ;
42051   Dali::CameraActor *arg1 = 0 ;
42052   Dali::CameraActor *result = 0 ;
42053
42054   arg1 = (Dali::CameraActor *)jarg1;
42055   if (!arg1) {
42056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42057     return 0;
42058   }
42059   {
42060     try {
42061       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
42062     } catch (std::out_of_range& e) {
42063       {
42064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42065       };
42066     } catch (std::exception& e) {
42067       {
42068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42069       };
42070     } catch (...) {
42071       {
42072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42073       };
42074     }
42075   }
42076   jresult = (void *)result;
42077   return jresult;
42078 }
42079
42080
42081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
42082   void * jresult ;
42083   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42084   Dali::CameraActor *arg2 = 0 ;
42085   Dali::CameraActor *result = 0 ;
42086
42087   arg1 = (Dali::CameraActor *)jarg1;
42088   arg2 = (Dali::CameraActor *)jarg2;
42089   if (!arg2) {
42090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42091     return 0;
42092   }
42093   {
42094     try {
42095       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
42096     } catch (std::out_of_range& e) {
42097       {
42098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42099       };
42100     } catch (std::exception& e) {
42101       {
42102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42103       };
42104     } catch (...) {
42105       {
42106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42107       };
42108     }
42109   }
42110   jresult = (void *)result;
42111   return jresult;
42112 }
42113
42114
42115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
42116   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42117   Dali::Camera::Type arg2 ;
42118
42119   arg1 = (Dali::CameraActor *)jarg1;
42120   arg2 = (Dali::Camera::Type)jarg2;
42121   {
42122     try {
42123       (arg1)->SetType(arg2);
42124     } catch (std::out_of_range& e) {
42125       {
42126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42127       };
42128     } catch (std::exception& e) {
42129       {
42130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42131       };
42132     } catch (...) {
42133       {
42134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42135       };
42136     }
42137   }
42138 }
42139
42140
42141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
42142   int jresult ;
42143   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42144   Dali::Camera::Type result;
42145
42146   arg1 = (Dali::CameraActor *)jarg1;
42147   {
42148     try {
42149       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
42150     } catch (std::out_of_range& e) {
42151       {
42152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42153       };
42154     } catch (std::exception& e) {
42155       {
42156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42157       };
42158     } catch (...) {
42159       {
42160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42161       };
42162     }
42163   }
42164   jresult = (int)result;
42165   return jresult;
42166 }
42167
42168
42169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
42170   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42171   Dali::Camera::ProjectionMode arg2 ;
42172
42173   arg1 = (Dali::CameraActor *)jarg1;
42174   arg2 = (Dali::Camera::ProjectionMode)jarg2;
42175   {
42176     try {
42177       (arg1)->SetProjectionMode(arg2);
42178     } catch (std::out_of_range& e) {
42179       {
42180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42181       };
42182     } catch (std::exception& e) {
42183       {
42184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42185       };
42186     } catch (...) {
42187       {
42188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42189       };
42190     }
42191   }
42192 }
42193
42194
42195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
42196   int jresult ;
42197   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42198   Dali::Camera::ProjectionMode result;
42199
42200   arg1 = (Dali::CameraActor *)jarg1;
42201   {
42202     try {
42203       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
42204     } catch (std::out_of_range& e) {
42205       {
42206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42207       };
42208     } catch (std::exception& e) {
42209       {
42210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42211       };
42212     } catch (...) {
42213       {
42214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42215       };
42216     }
42217   }
42218   jresult = (int)result;
42219   return jresult;
42220 }
42221
42222
42223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
42224   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42225   float arg2 ;
42226
42227   arg1 = (Dali::CameraActor *)jarg1;
42228   arg2 = (float)jarg2;
42229   {
42230     try {
42231       (arg1)->SetFieldOfView(arg2);
42232     } catch (std::out_of_range& e) {
42233       {
42234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42235       };
42236     } catch (std::exception& e) {
42237       {
42238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42239       };
42240     } catch (...) {
42241       {
42242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42243       };
42244     }
42245   }
42246 }
42247
42248
42249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
42250   float jresult ;
42251   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42252   float result;
42253
42254   arg1 = (Dali::CameraActor *)jarg1;
42255   {
42256     try {
42257       result = (float)(arg1)->GetFieldOfView();
42258     } catch (std::out_of_range& e) {
42259       {
42260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42261       };
42262     } catch (std::exception& e) {
42263       {
42264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42265       };
42266     } catch (...) {
42267       {
42268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42269       };
42270     }
42271   }
42272   jresult = result;
42273   return jresult;
42274 }
42275
42276
42277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
42278   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42279   float arg2 ;
42280
42281   arg1 = (Dali::CameraActor *)jarg1;
42282   arg2 = (float)jarg2;
42283   {
42284     try {
42285       (arg1)->SetAspectRatio(arg2);
42286     } catch (std::out_of_range& e) {
42287       {
42288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42289       };
42290     } catch (std::exception& e) {
42291       {
42292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42293       };
42294     } catch (...) {
42295       {
42296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42297       };
42298     }
42299   }
42300 }
42301
42302
42303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
42304   float jresult ;
42305   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42306   float result;
42307
42308   arg1 = (Dali::CameraActor *)jarg1;
42309   {
42310     try {
42311       result = (float)(arg1)->GetAspectRatio();
42312     } catch (std::out_of_range& e) {
42313       {
42314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42315       };
42316     } catch (std::exception& e) {
42317       {
42318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42319       };
42320     } catch (...) {
42321       {
42322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42323       };
42324     }
42325   }
42326   jresult = result;
42327   return jresult;
42328 }
42329
42330
42331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
42332   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42333   float arg2 ;
42334
42335   arg1 = (Dali::CameraActor *)jarg1;
42336   arg2 = (float)jarg2;
42337   {
42338     try {
42339       (arg1)->SetNearClippingPlane(arg2);
42340     } catch (std::out_of_range& e) {
42341       {
42342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42343       };
42344     } catch (std::exception& e) {
42345       {
42346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42347       };
42348     } catch (...) {
42349       {
42350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42351       };
42352     }
42353   }
42354 }
42355
42356
42357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
42358   float jresult ;
42359   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42360   float result;
42361
42362   arg1 = (Dali::CameraActor *)jarg1;
42363   {
42364     try {
42365       result = (float)(arg1)->GetNearClippingPlane();
42366     } catch (std::out_of_range& e) {
42367       {
42368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42369       };
42370     } catch (std::exception& e) {
42371       {
42372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42373       };
42374     } catch (...) {
42375       {
42376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42377       };
42378     }
42379   }
42380   jresult = result;
42381   return jresult;
42382 }
42383
42384
42385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
42386   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42387   float arg2 ;
42388
42389   arg1 = (Dali::CameraActor *)jarg1;
42390   arg2 = (float)jarg2;
42391   {
42392     try {
42393       (arg1)->SetFarClippingPlane(arg2);
42394     } catch (std::out_of_range& e) {
42395       {
42396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42397       };
42398     } catch (std::exception& e) {
42399       {
42400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42401       };
42402     } catch (...) {
42403       {
42404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42405       };
42406     }
42407   }
42408 }
42409
42410
42411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
42412   float jresult ;
42413   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42414   float result;
42415
42416   arg1 = (Dali::CameraActor *)jarg1;
42417   {
42418     try {
42419       result = (float)(arg1)->GetFarClippingPlane();
42420     } catch (std::out_of_range& e) {
42421       {
42422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42423       };
42424     } catch (std::exception& e) {
42425       {
42426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42427       };
42428     } catch (...) {
42429       {
42430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42431       };
42432     }
42433   }
42434   jresult = result;
42435   return jresult;
42436 }
42437
42438
42439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
42440   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42441   Dali::Vector3 *arg2 = 0 ;
42442
42443   arg1 = (Dali::CameraActor *)jarg1;
42444   arg2 = (Dali::Vector3 *)jarg2;
42445   if (!arg2) {
42446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42447     return ;
42448   }
42449   {
42450     try {
42451       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
42452     } catch (std::out_of_range& e) {
42453       {
42454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42455       };
42456     } catch (std::exception& e) {
42457       {
42458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42459       };
42460     } catch (...) {
42461       {
42462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42463       };
42464     }
42465   }
42466 }
42467
42468
42469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
42470   void * jresult ;
42471   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42472   Dali::Vector3 result;
42473
42474   arg1 = (Dali::CameraActor *)jarg1;
42475   {
42476     try {
42477       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
42478     } catch (std::out_of_range& e) {
42479       {
42480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42481       };
42482     } catch (std::exception& e) {
42483       {
42484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42485       };
42486     } catch (...) {
42487       {
42488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42489       };
42490     }
42491   }
42492   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42493   return jresult;
42494 }
42495
42496
42497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
42498   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42499   bool arg2 ;
42500
42501   arg1 = (Dali::CameraActor *)jarg1;
42502   arg2 = jarg2 ? true : false;
42503   {
42504     try {
42505       (arg1)->SetInvertYAxis(arg2);
42506     } catch (std::out_of_range& e) {
42507       {
42508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42509       };
42510     } catch (std::exception& e) {
42511       {
42512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42513       };
42514     } catch (...) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42517       };
42518     }
42519   }
42520 }
42521
42522
42523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
42524   unsigned int jresult ;
42525   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42526   bool result;
42527
42528   arg1 = (Dali::CameraActor *)jarg1;
42529   {
42530     try {
42531       result = (bool)(arg1)->GetInvertYAxis();
42532     } catch (std::out_of_range& e) {
42533       {
42534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42535       };
42536     } catch (std::exception& e) {
42537       {
42538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42539       };
42540     } catch (...) {
42541       {
42542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42543       };
42544     }
42545   }
42546   jresult = result;
42547   return jresult;
42548 }
42549
42550
42551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
42552   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42553   Dali::Size *arg2 = 0 ;
42554
42555   arg1 = (Dali::CameraActor *)jarg1;
42556   arg2 = (Dali::Size *)jarg2;
42557   if (!arg2) {
42558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42559     return ;
42560   }
42561   {
42562     try {
42563       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
42564     } catch (std::out_of_range& e) {
42565       {
42566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42567       };
42568     } catch (std::exception& e) {
42569       {
42570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42571       };
42572     } catch (...) {
42573       {
42574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42575       };
42576     }
42577   }
42578 }
42579
42580
42581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
42582   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42583   Dali::Size *arg2 = 0 ;
42584
42585   arg1 = (Dali::CameraActor *)jarg1;
42586   arg2 = (Dali::Size *)jarg2;
42587   if (!arg2) {
42588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42589     return ;
42590   }
42591   {
42592     try {
42593       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
42594     } catch (std::out_of_range& e) {
42595       {
42596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42597       };
42598     } catch (std::exception& e) {
42599       {
42600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42601       };
42602     } catch (...) {
42603       {
42604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42605       };
42606     }
42607   }
42608 }
42609
42610
42611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
42612   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42613   float arg2 ;
42614   float arg3 ;
42615   float arg4 ;
42616   float arg5 ;
42617   float arg6 ;
42618   float arg7 ;
42619
42620   arg1 = (Dali::CameraActor *)jarg1;
42621   arg2 = (float)jarg2;
42622   arg3 = (float)jarg3;
42623   arg4 = (float)jarg4;
42624   arg5 = (float)jarg5;
42625   arg6 = (float)jarg6;
42626   arg7 = (float)jarg7;
42627   {
42628     try {
42629       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
42630     } catch (std::out_of_range& e) {
42631       {
42632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42633       };
42634     } catch (std::exception& e) {
42635       {
42636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42637       };
42638     } catch (...) {
42639       {
42640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42641       };
42642     }
42643   }
42644 }
42645
42646
42647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
42648   void * jresult ;
42649   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42650
42651   {
42652     try {
42653       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
42654     } catch (std::out_of_range& e) {
42655       {
42656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42657       };
42658     } catch (std::exception& e) {
42659       {
42660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42661       };
42662     } catch (...) {
42663       {
42664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42665       };
42666     }
42667   }
42668   jresult = (void *)result;
42669   return jresult;
42670 }
42671
42672
42673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
42674   void * jresult ;
42675   std::string arg1 ;
42676   Dali::Property::Value arg2 ;
42677   Dali::Property::Value *argp2 ;
42678   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42679
42680   if (!jarg1) {
42681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42682     return 0;
42683   }
42684   (&arg1)->assign(jarg1);
42685   argp2 = (Dali::Property::Value *)jarg2;
42686   if (!argp2) {
42687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42688     return 0;
42689   }
42690   arg2 = *argp2;
42691   {
42692     try {
42693       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
42694     } catch (std::out_of_range& e) {
42695       {
42696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42697       };
42698     } catch (std::exception& e) {
42699       {
42700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42701       };
42702     } catch (...) {
42703       {
42704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42705       };
42706     }
42707   }
42708   jresult = (void *)result;
42709   return jresult;
42710 }
42711
42712
42713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
42714   void * jresult ;
42715   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
42716   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42717
42718   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42719   if (!arg1) {
42720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
42721     return 0;
42722   }
42723   {
42724     try {
42725       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);
42726     } catch (std::out_of_range& e) {
42727       {
42728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42729       };
42730     } catch (std::exception& e) {
42731       {
42732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42733       };
42734     } catch (...) {
42735       {
42736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42737       };
42738     }
42739   }
42740   jresult = (void *)result;
42741   return jresult;
42742 }
42743
42744
42745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
42746   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42747   std::string *arg2 = 0 ;
42748
42749   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42750   if (!jarg2) {
42751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42752     return ;
42753   }
42754   std::string arg2_str(jarg2);
42755   arg2 = &arg2_str;
42756   if (arg1) (arg1)->first = *arg2;
42757
42758   //argout typemap for const std::string&
42759
42760 }
42761
42762
42763 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
42764   char * jresult ;
42765   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42766   std::string *result = 0 ;
42767
42768   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42769   result = (std::string *) & ((arg1)->first);
42770   jresult = SWIG_csharp_string_callback(result->c_str());
42771   return jresult;
42772 }
42773
42774
42775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
42776   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42777   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
42778
42779   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42780   arg2 = (Dali::Property::Value *)jarg2;
42781   if (arg1) (arg1)->second = *arg2;
42782 }
42783
42784
42785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
42786   void * jresult ;
42787   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42788   Dali::Property::Value *result = 0 ;
42789
42790   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42791   result = (Dali::Property::Value *)& ((arg1)->second);
42792   jresult = (void *)result;
42793   return jresult;
42794 }
42795
42796
42797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
42798   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42799
42800   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42801   {
42802     try {
42803       delete arg1;
42804     } catch (std::out_of_range& e) {
42805       {
42806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42807       };
42808     } catch (std::exception& e) {
42809       {
42810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42811       };
42812     } catch (...) {
42813       {
42814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42815       };
42816     }
42817   }
42818 }
42819
42820
42821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
42822   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42823
42824   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42825   {
42826     try {
42827       (arg1)->clear();
42828     } catch (std::out_of_range& e) {
42829       {
42830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42831       };
42832     } catch (std::exception& e) {
42833       {
42834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42835       };
42836     } catch (...) {
42837       {
42838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42839       };
42840     }
42841   }
42842 }
42843
42844
42845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
42846   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42847   Dali::TouchPoint *arg2 = 0 ;
42848
42849   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42850   arg2 = (Dali::TouchPoint *)jarg2;
42851   if (!arg2) {
42852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
42853     return ;
42854   }
42855   {
42856     try {
42857       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
42858     } catch (std::out_of_range& e) {
42859       {
42860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42861       };
42862     } catch (std::exception& e) {
42863       {
42864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42865       };
42866     } catch (...) {
42867       {
42868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42869       };
42870     }
42871   }
42872 }
42873
42874
42875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
42876   unsigned long jresult ;
42877   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42878   std::vector< Dali::TouchPoint >::size_type result;
42879
42880   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42881   {
42882     try {
42883       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
42884     } catch (std::out_of_range& e) {
42885       {
42886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42887       };
42888     } catch (std::exception& e) {
42889       {
42890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42891       };
42892     } catch (...) {
42893       {
42894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42895       };
42896     }
42897   }
42898   jresult = (unsigned long)result;
42899   return jresult;
42900 }
42901
42902
42903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
42904   unsigned long jresult ;
42905   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42906   std::vector< Dali::TouchPoint >::size_type result;
42907
42908   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42909   {
42910     try {
42911       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
42912     } catch (std::out_of_range& e) {
42913       {
42914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42915       };
42916     } catch (std::exception& e) {
42917       {
42918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42919       };
42920     } catch (...) {
42921       {
42922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42923       };
42924     }
42925   }
42926   jresult = (unsigned long)result;
42927   return jresult;
42928 }
42929
42930
42931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
42932   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42933   std::vector< Dali::TouchPoint >::size_type arg2 ;
42934
42935   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42936   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
42937   {
42938     try {
42939       (arg1)->reserve(arg2);
42940     } catch (std::out_of_range& e) {
42941       {
42942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42943       };
42944     } catch (std::exception& e) {
42945       {
42946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42947       };
42948     } catch (...) {
42949       {
42950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42951       };
42952     }
42953   }
42954 }
42955
42956
42957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
42958   void * jresult ;
42959   std::vector< Dali::TouchPoint > *result = 0 ;
42960
42961   {
42962     try {
42963       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
42964     } catch (std::out_of_range& e) {
42965       {
42966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42967       };
42968     } catch (std::exception& e) {
42969       {
42970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42971       };
42972     } catch (...) {
42973       {
42974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42975       };
42976     }
42977   }
42978   jresult = (void *)result;
42979   return jresult;
42980 }
42981
42982
42983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
42984   void * jresult ;
42985   std::vector< Dali::TouchPoint > *arg1 = 0 ;
42986   std::vector< Dali::TouchPoint > *result = 0 ;
42987
42988   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42989   if (!arg1) {
42990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
42991     return 0;
42992   }
42993   {
42994     try {
42995       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
42996     } catch (std::out_of_range& e) {
42997       {
42998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42999       };
43000     } catch (std::exception& e) {
43001       {
43002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43003       };
43004     } catch (...) {
43005       {
43006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43007       };
43008     }
43009   }
43010   jresult = (void *)result;
43011   return jresult;
43012 }
43013
43014
43015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
43016   void * jresult ;
43017   int arg1 ;
43018   std::vector< Dali::TouchPoint > *result = 0 ;
43019
43020   arg1 = (int)jarg1;
43021   {
43022     try {
43023       try {
43024         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
43025       }
43026       catch(std::out_of_range &_e) {
43027         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43028         return 0;
43029       }
43030
43031     } catch (std::out_of_range& e) {
43032       {
43033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43034       };
43035     } catch (std::exception& e) {
43036       {
43037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43038       };
43039     } catch (...) {
43040       {
43041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43042       };
43043     }
43044   }
43045   jresult = (void *)result;
43046   return jresult;
43047 }
43048
43049
43050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
43051   void * jresult ;
43052   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43053   int arg2 ;
43054   SwigValueWrapper< Dali::TouchPoint > result;
43055
43056   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43057   arg2 = (int)jarg2;
43058   {
43059     try {
43060       try {
43061         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
43062       }
43063       catch(std::out_of_range &_e) {
43064         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43065         return 0;
43066       }
43067
43068     } catch (std::out_of_range& e) {
43069       {
43070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43071       };
43072     } catch (std::exception& e) {
43073       {
43074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43075       };
43076     } catch (...) {
43077       {
43078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43079       };
43080     }
43081   }
43082   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
43083   return jresult;
43084 }
43085
43086
43087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
43088   void * jresult ;
43089   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43090   int arg2 ;
43091   Dali::TouchPoint *result = 0 ;
43092
43093   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43094   arg2 = (int)jarg2;
43095   {
43096     try {
43097       try {
43098         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
43099       }
43100       catch(std::out_of_range &_e) {
43101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43102         return 0;
43103       }
43104
43105     } catch (std::out_of_range& e) {
43106       {
43107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43108       };
43109     } catch (std::exception& e) {
43110       {
43111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43112       };
43113     } catch (...) {
43114       {
43115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43116       };
43117     }
43118   }
43119   jresult = (void *)result;
43120   return jresult;
43121 }
43122
43123
43124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
43125   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43126   int arg2 ;
43127   Dali::TouchPoint *arg3 = 0 ;
43128
43129   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43130   arg2 = (int)jarg2;
43131   arg3 = (Dali::TouchPoint *)jarg3;
43132   if (!arg3) {
43133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43134     return ;
43135   }
43136   {
43137     try {
43138       try {
43139         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43140       }
43141       catch(std::out_of_range &_e) {
43142         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43143         return ;
43144       }
43145
43146     } catch (std::out_of_range& e) {
43147       {
43148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43149       };
43150     } catch (std::exception& e) {
43151       {
43152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43153       };
43154     } catch (...) {
43155       {
43156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43157       };
43158     }
43159   }
43160 }
43161
43162
43163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
43164   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43165   std::vector< Dali::TouchPoint > *arg2 = 0 ;
43166
43167   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43168   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
43169   if (!arg2) {
43170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43171     return ;
43172   }
43173   {
43174     try {
43175       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
43176     } catch (std::out_of_range& e) {
43177       {
43178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43179       };
43180     } catch (std::exception& e) {
43181       {
43182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43183       };
43184     } catch (...) {
43185       {
43186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43187       };
43188     }
43189   }
43190 }
43191
43192
43193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
43194   void * jresult ;
43195   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43196   int arg2 ;
43197   int arg3 ;
43198   std::vector< Dali::TouchPoint > *result = 0 ;
43199
43200   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43201   arg2 = (int)jarg2;
43202   arg3 = (int)jarg3;
43203   {
43204     try {
43205       try {
43206         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
43207       }
43208       catch(std::out_of_range &_e) {
43209         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43210         return 0;
43211       }
43212       catch(std::invalid_argument &_e) {
43213         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43214         return 0;
43215       }
43216
43217     } catch (std::out_of_range& e) {
43218       {
43219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43220       };
43221     } catch (std::exception& e) {
43222       {
43223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43224       };
43225     } catch (...) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43228       };
43229     }
43230   }
43231   jresult = (void *)result;
43232   return jresult;
43233 }
43234
43235
43236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
43237   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43238   int arg2 ;
43239   Dali::TouchPoint *arg3 = 0 ;
43240
43241   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43242   arg2 = (int)jarg2;
43243   arg3 = (Dali::TouchPoint *)jarg3;
43244   if (!arg3) {
43245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43246     return ;
43247   }
43248   {
43249     try {
43250       try {
43251         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43252       }
43253       catch(std::out_of_range &_e) {
43254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43255         return ;
43256       }
43257
43258     } catch (std::out_of_range& e) {
43259       {
43260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43261       };
43262     } catch (std::exception& e) {
43263       {
43264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43265       };
43266     } catch (...) {
43267       {
43268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43269       };
43270     }
43271   }
43272 }
43273
43274
43275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
43276   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43277   int arg2 ;
43278   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43279
43280   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43281   arg2 = (int)jarg2;
43282   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43283   if (!arg3) {
43284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43285     return ;
43286   }
43287   {
43288     try {
43289       try {
43290         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43291       }
43292       catch(std::out_of_range &_e) {
43293         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43294         return ;
43295       }
43296
43297     } catch (std::out_of_range& e) {
43298       {
43299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43300       };
43301     } catch (std::exception& e) {
43302       {
43303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43304       };
43305     } catch (...) {
43306       {
43307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43308       };
43309     }
43310   }
43311 }
43312
43313
43314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
43315   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43316   int arg2 ;
43317
43318   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43319   arg2 = (int)jarg2;
43320   {
43321     try {
43322       try {
43323         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
43324       }
43325       catch(std::out_of_range &_e) {
43326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43327         return ;
43328       }
43329
43330     } catch (std::out_of_range& e) {
43331       {
43332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43333       };
43334     } catch (std::exception& e) {
43335       {
43336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43337       };
43338     } catch (...) {
43339       {
43340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43341       };
43342     }
43343   }
43344 }
43345
43346
43347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
43348   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43349   int arg2 ;
43350   int arg3 ;
43351
43352   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43353   arg2 = (int)jarg2;
43354   arg3 = (int)jarg3;
43355   {
43356     try {
43357       try {
43358         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
43359       }
43360       catch(std::out_of_range &_e) {
43361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43362         return ;
43363       }
43364       catch(std::invalid_argument &_e) {
43365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43366         return ;
43367       }
43368
43369     } catch (std::out_of_range& e) {
43370       {
43371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43372       };
43373     } catch (std::exception& e) {
43374       {
43375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43376       };
43377     } catch (...) {
43378       {
43379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43380       };
43381     }
43382   }
43383 }
43384
43385
43386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
43387   void * jresult ;
43388   Dali::TouchPoint *arg1 = 0 ;
43389   int arg2 ;
43390   std::vector< Dali::TouchPoint > *result = 0 ;
43391
43392   arg1 = (Dali::TouchPoint *)jarg1;
43393   if (!arg1) {
43394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43395     return 0;
43396   }
43397   arg2 = (int)jarg2;
43398   {
43399     try {
43400       try {
43401         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
43402       }
43403       catch(std::out_of_range &_e) {
43404         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43405         return 0;
43406       }
43407
43408     } catch (std::out_of_range& e) {
43409       {
43410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43411       };
43412     } catch (std::exception& e) {
43413       {
43414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43415       };
43416     } catch (...) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43419       };
43420     }
43421   }
43422   jresult = (void *)result;
43423   return jresult;
43424 }
43425
43426
43427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
43428   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43429
43430   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43431   {
43432     try {
43433       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
43434     } catch (std::out_of_range& e) {
43435       {
43436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43437       };
43438     } catch (std::exception& e) {
43439       {
43440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43441       };
43442     } catch (...) {
43443       {
43444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43445       };
43446     }
43447   }
43448 }
43449
43450
43451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
43452   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43453   int arg2 ;
43454   int arg3 ;
43455
43456   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43457   arg2 = (int)jarg2;
43458   arg3 = (int)jarg3;
43459   {
43460     try {
43461       try {
43462         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
43463       }
43464       catch(std::out_of_range &_e) {
43465         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43466         return ;
43467       }
43468       catch(std::invalid_argument &_e) {
43469         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43470         return ;
43471       }
43472
43473     } catch (std::out_of_range& e) {
43474       {
43475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43476       };
43477     } catch (std::exception& e) {
43478       {
43479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43480       };
43481     } catch (...) {
43482       {
43483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43484       };
43485     }
43486   }
43487 }
43488
43489
43490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
43491   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43492   int arg2 ;
43493   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43494
43495   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43496   arg2 = (int)jarg2;
43497   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43498   if (!arg3) {
43499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43500     return ;
43501   }
43502   {
43503     try {
43504       try {
43505         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43506       }
43507       catch(std::out_of_range &_e) {
43508         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43509         return ;
43510       }
43511
43512     } catch (std::out_of_range& e) {
43513       {
43514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43515       };
43516     } catch (std::exception& e) {
43517       {
43518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43519       };
43520     } catch (...) {
43521       {
43522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43523       };
43524     }
43525   }
43526 }
43527
43528
43529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
43530   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43531
43532   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43533   {
43534     try {
43535       delete arg1;
43536     } catch (std::out_of_range& e) {
43537       {
43538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43539       };
43540     } catch (std::exception& e) {
43541       {
43542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43543       };
43544     } catch (...) {
43545       {
43546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43547       };
43548     }
43549   }
43550 }
43551
43552
43553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
43554   void * jresult ;
43555   Dali::Rect< int > *result = 0 ;
43556
43557   {
43558     try {
43559       result = (Dali::Rect< int > *)new Dali::Rect< int >();
43560     } catch (std::out_of_range& e) {
43561       {
43562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43563       };
43564     } catch (std::exception& e) {
43565       {
43566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43567       };
43568     } catch (...) {
43569       {
43570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43571       };
43572     }
43573   }
43574   jresult = (void *)result;
43575   return jresult;
43576 }
43577
43578
43579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
43580   void * jresult ;
43581   int arg1 ;
43582   int arg2 ;
43583   int arg3 ;
43584   int arg4 ;
43585   Dali::Rect< int > *result = 0 ;
43586
43587   arg1 = (int)jarg1;
43588   arg2 = (int)jarg2;
43589   arg3 = (int)jarg3;
43590   arg4 = (int)jarg4;
43591   {
43592     try {
43593       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
43594     } catch (std::out_of_range& e) {
43595       {
43596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43597       };
43598     } catch (std::exception& e) {
43599       {
43600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43601       };
43602     } catch (...) {
43603       {
43604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43605       };
43606     }
43607   }
43608   jresult = (void *)result;
43609   return jresult;
43610 }
43611
43612
43613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
43614   void * jresult ;
43615   Dali::Rect< int > *arg1 = 0 ;
43616   Dali::Rect< int > *result = 0 ;
43617
43618   arg1 = (Dali::Rect< int > *)jarg1;
43619   if (!arg1) {
43620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43621     return 0;
43622   }
43623   {
43624     try {
43625       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
43626     } catch (std::out_of_range& e) {
43627       {
43628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43629       };
43630     } catch (std::exception& e) {
43631       {
43632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43633       };
43634     } catch (...) {
43635       {
43636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43637       };
43638     }
43639   }
43640   jresult = (void *)result;
43641   return jresult;
43642 }
43643
43644
43645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
43646   void * jresult ;
43647   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43648   Dali::Rect< int > *arg2 = 0 ;
43649   Dali::Rect< int > *result = 0 ;
43650
43651   arg1 = (Dali::Rect< int > *)jarg1;
43652   arg2 = (Dali::Rect< int > *)jarg2;
43653   if (!arg2) {
43654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43655     return 0;
43656   }
43657   {
43658     try {
43659       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
43660     } catch (std::out_of_range& e) {
43661       {
43662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43663       };
43664     } catch (std::exception& e) {
43665       {
43666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43667       };
43668     } catch (...) {
43669       {
43670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43671       };
43672     }
43673   }
43674   jresult = (void *)result;
43675   return jresult;
43676 }
43677
43678
43679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
43680   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43681   int arg2 ;
43682   int arg3 ;
43683   int arg4 ;
43684   int arg5 ;
43685
43686   arg1 = (Dali::Rect< int > *)jarg1;
43687   arg2 = (int)jarg2;
43688   arg3 = (int)jarg3;
43689   arg4 = (int)jarg4;
43690   arg5 = (int)jarg5;
43691   {
43692     try {
43693       (arg1)->Set(arg2,arg3,arg4,arg5);
43694     } catch (std::out_of_range& e) {
43695       {
43696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43697       };
43698     } catch (std::exception& e) {
43699       {
43700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43701       };
43702     } catch (...) {
43703       {
43704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43705       };
43706     }
43707   }
43708 }
43709
43710
43711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
43712   unsigned int jresult ;
43713   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43714   bool result;
43715
43716   arg1 = (Dali::Rect< int > *)jarg1;
43717   {
43718     try {
43719       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
43720     } catch (std::out_of_range& e) {
43721       {
43722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43723       };
43724     } catch (std::exception& e) {
43725       {
43726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43727       };
43728     } catch (...) {
43729       {
43730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43731       };
43732     }
43733   }
43734   jresult = result;
43735   return jresult;
43736 }
43737
43738
43739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
43740   int jresult ;
43741   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43742   int result;
43743
43744   arg1 = (Dali::Rect< int > *)jarg1;
43745   {
43746     try {
43747       result = (int)((Dali::Rect< int > const *)arg1)->Left();
43748     } catch (std::out_of_range& e) {
43749       {
43750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43751       };
43752     } catch (std::exception& e) {
43753       {
43754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43755       };
43756     } catch (...) {
43757       {
43758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43759       };
43760     }
43761   }
43762   jresult = result;
43763   return jresult;
43764 }
43765
43766
43767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
43768   int jresult ;
43769   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43770   int result;
43771
43772   arg1 = (Dali::Rect< int > *)jarg1;
43773   {
43774     try {
43775       result = (int)((Dali::Rect< int > const *)arg1)->Right();
43776     } catch (std::out_of_range& e) {
43777       {
43778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43779       };
43780     } catch (std::exception& e) {
43781       {
43782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43783       };
43784     } catch (...) {
43785       {
43786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43787       };
43788     }
43789   }
43790   jresult = result;
43791   return jresult;
43792 }
43793
43794
43795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
43796   int jresult ;
43797   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43798   int result;
43799
43800   arg1 = (Dali::Rect< int > *)jarg1;
43801   {
43802     try {
43803       result = (int)((Dali::Rect< int > const *)arg1)->Top();
43804     } catch (std::out_of_range& e) {
43805       {
43806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43807       };
43808     } catch (std::exception& e) {
43809       {
43810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43811       };
43812     } catch (...) {
43813       {
43814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43815       };
43816     }
43817   }
43818   jresult = result;
43819   return jresult;
43820 }
43821
43822
43823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
43824   int jresult ;
43825   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43826   int result;
43827
43828   arg1 = (Dali::Rect< int > *)jarg1;
43829   {
43830     try {
43831       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
43832     } catch (std::out_of_range& e) {
43833       {
43834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43835       };
43836     } catch (std::exception& e) {
43837       {
43838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43839       };
43840     } catch (...) {
43841       {
43842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43843       };
43844     }
43845   }
43846   jresult = result;
43847   return jresult;
43848 }
43849
43850
43851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
43852   int jresult ;
43853   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43854   int result;
43855
43856   arg1 = (Dali::Rect< int > *)jarg1;
43857   {
43858     try {
43859       result = (int)((Dali::Rect< int > const *)arg1)->Area();
43860     } catch (std::out_of_range& e) {
43861       {
43862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43863       };
43864     } catch (std::exception& e) {
43865       {
43866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43867       };
43868     } catch (...) {
43869       {
43870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43871       };
43872     }
43873   }
43874   jresult = result;
43875   return jresult;
43876 }
43877
43878
43879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
43880   unsigned int jresult ;
43881   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43882   Dali::Rect< int > *arg2 = 0 ;
43883   bool result;
43884
43885   arg1 = (Dali::Rect< int > *)jarg1;
43886   arg2 = (Dali::Rect< int > *)jarg2;
43887   if (!arg2) {
43888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43889     return 0;
43890   }
43891   {
43892     try {
43893       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
43894     } catch (std::out_of_range& e) {
43895       {
43896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43897       };
43898     } catch (std::exception& e) {
43899       {
43900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43901       };
43902     } catch (...) {
43903       {
43904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43905       };
43906     }
43907   }
43908   jresult = result;
43909   return jresult;
43910 }
43911
43912
43913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
43914   unsigned int jresult ;
43915   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43916   Dali::Rect< int > *arg2 = 0 ;
43917   bool result;
43918
43919   arg1 = (Dali::Rect< int > *)jarg1;
43920   arg2 = (Dali::Rect< int > *)jarg2;
43921   if (!arg2) {
43922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43923     return 0;
43924   }
43925   {
43926     try {
43927       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
43928     } catch (std::out_of_range& e) {
43929       {
43930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43931       };
43932     } catch (std::exception& e) {
43933       {
43934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43935       };
43936     } catch (...) {
43937       {
43938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43939       };
43940     }
43941   }
43942   jresult = result;
43943   return jresult;
43944 }
43945
43946
43947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
43948   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43949   int arg2 ;
43950
43951   arg1 = (Dali::Rect< int > *)jarg1;
43952   arg2 = (int)jarg2;
43953   if (arg1) (arg1)->x = arg2;
43954 }
43955
43956
43957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
43958   int jresult ;
43959   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43960   int result;
43961
43962   arg1 = (Dali::Rect< int > *)jarg1;
43963   result = (int) ((arg1)->x);
43964   jresult = result;
43965   return jresult;
43966 }
43967
43968
43969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
43970   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43971   int arg2 ;
43972
43973   arg1 = (Dali::Rect< int > *)jarg1;
43974   arg2 = (int)jarg2;
43975   if (arg1) (arg1)->left = arg2;
43976 }
43977
43978
43979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
43980   int jresult ;
43981   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43982   int result;
43983
43984   arg1 = (Dali::Rect< int > *)jarg1;
43985   result = (int) ((arg1)->left);
43986   jresult = result;
43987   return jresult;
43988 }
43989
43990
43991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
43992   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43993   int arg2 ;
43994
43995   arg1 = (Dali::Rect< int > *)jarg1;
43996   arg2 = (int)jarg2;
43997   if (arg1) (arg1)->y = arg2;
43998 }
43999
44000
44001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
44002   int jresult ;
44003   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44004   int result;
44005
44006   arg1 = (Dali::Rect< int > *)jarg1;
44007   result = (int) ((arg1)->y);
44008   jresult = result;
44009   return jresult;
44010 }
44011
44012
44013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
44014   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44015   int arg2 ;
44016
44017   arg1 = (Dali::Rect< int > *)jarg1;
44018   arg2 = (int)jarg2;
44019   if (arg1) (arg1)->right = arg2;
44020 }
44021
44022
44023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
44024   int jresult ;
44025   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44026   int result;
44027
44028   arg1 = (Dali::Rect< int > *)jarg1;
44029   result = (int) ((arg1)->right);
44030   jresult = result;
44031   return jresult;
44032 }
44033
44034
44035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
44036   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44037   int arg2 ;
44038
44039   arg1 = (Dali::Rect< int > *)jarg1;
44040   arg2 = (int)jarg2;
44041   if (arg1) (arg1)->width = arg2;
44042 }
44043
44044
44045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
44046   int jresult ;
44047   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44048   int result;
44049
44050   arg1 = (Dali::Rect< int > *)jarg1;
44051   result = (int) ((arg1)->width);
44052   jresult = result;
44053   return jresult;
44054 }
44055
44056
44057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
44058   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44059   int arg2 ;
44060
44061   arg1 = (Dali::Rect< int > *)jarg1;
44062   arg2 = (int)jarg2;
44063   if (arg1) (arg1)->bottom = arg2;
44064 }
44065
44066
44067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
44068   int jresult ;
44069   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44070   int result;
44071
44072   arg1 = (Dali::Rect< int > *)jarg1;
44073   result = (int) ((arg1)->bottom);
44074   jresult = result;
44075   return jresult;
44076 }
44077
44078
44079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
44080   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44081   int arg2 ;
44082
44083   arg1 = (Dali::Rect< int > *)jarg1;
44084   arg2 = (int)jarg2;
44085   if (arg1) (arg1)->height = arg2;
44086 }
44087
44088
44089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
44090   int jresult ;
44091   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44092   int result;
44093
44094   arg1 = (Dali::Rect< int > *)jarg1;
44095   result = (int) ((arg1)->height);
44096   jresult = result;
44097   return jresult;
44098 }
44099
44100
44101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
44102   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44103   int arg2 ;
44104
44105   arg1 = (Dali::Rect< int > *)jarg1;
44106   arg2 = (int)jarg2;
44107   if (arg1) (arg1)->top = arg2;
44108 }
44109
44110
44111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
44112   int jresult ;
44113   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44114   int result;
44115
44116   arg1 = (Dali::Rect< int > *)jarg1;
44117   result = (int) ((arg1)->top);
44118   jresult = result;
44119   return jresult;
44120 }
44121
44122
44123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
44124   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44125
44126   arg1 = (Dali::Rect< int > *)jarg1;
44127   {
44128     try {
44129       delete arg1;
44130     } catch (std::out_of_range& e) {
44131       {
44132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44133       };
44134     } catch (std::exception& e) {
44135       {
44136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44137       };
44138     } catch (...) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44141       };
44142     }
44143   }
44144 }
44145
44146
44147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
44148   void * jresult ;
44149   Dali::Rect< float > *result = 0 ;
44150
44151   {
44152     try {
44153       result = (Dali::Rect< float > *)new Dali::Rect< float >();
44154     } catch (std::out_of_range& e) {
44155       {
44156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44157       };
44158     } catch (std::exception& e) {
44159       {
44160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44161       };
44162     } catch (...) {
44163       {
44164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44165       };
44166     }
44167   }
44168   jresult = (void *)result;
44169   return jresult;
44170 }
44171
44172
44173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
44174   void * jresult ;
44175   float arg1 ;
44176   float arg2 ;
44177   float arg3 ;
44178   float arg4 ;
44179   Dali::Rect< float > *result = 0 ;
44180
44181   arg1 = (float)jarg1;
44182   arg2 = (float)jarg2;
44183   arg3 = (float)jarg4;
44184   arg4 = (float)jarg3;
44185   {
44186     try {
44187       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
44188     } catch (std::out_of_range& e) {
44189       {
44190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44191       };
44192     } catch (std::exception& e) {
44193       {
44194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44195       };
44196     } catch (...) {
44197       {
44198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44199       };
44200     }
44201   }
44202   jresult = (void *)result;
44203   return jresult;
44204 }
44205
44206
44207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
44208   void * jresult ;
44209   Dali::Rect< float > *arg1 = 0 ;
44210   Dali::Rect< float > *result = 0 ;
44211
44212   arg1 = (Dali::Rect< float > *)jarg1;
44213   if (!arg1) {
44214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44215     return 0;
44216   }
44217   {
44218     try {
44219       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
44220     } catch (std::out_of_range& e) {
44221       {
44222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44223       };
44224     } catch (std::exception& e) {
44225       {
44226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44227       };
44228     } catch (...) {
44229       {
44230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44231       };
44232     }
44233   }
44234   jresult = (void *)result;
44235   return jresult;
44236 }
44237
44238
44239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
44240   void * jresult ;
44241   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44242   Dali::Rect< float > *arg2 = 0 ;
44243   Dali::Rect< float > *result = 0 ;
44244
44245   arg1 = (Dali::Rect< float > *)jarg1;
44246   arg2 = (Dali::Rect< float > *)jarg2;
44247   if (!arg2) {
44248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44249     return 0;
44250   }
44251   {
44252     try {
44253       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
44254     } catch (std::out_of_range& e) {
44255       {
44256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44257       };
44258     } catch (std::exception& e) {
44259       {
44260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44261       };
44262     } catch (...) {
44263       {
44264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44265       };
44266     }
44267   }
44268   jresult = (void *)result;
44269   return jresult;
44270 }
44271
44272
44273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
44274   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44275   float arg2 ;
44276   float arg3 ;
44277   float arg4 ;
44278   float arg5 ;
44279
44280   arg1 = (Dali::Rect< float > *)jarg1;
44281   arg2 = (float)jarg2;
44282   arg3 = (float)jarg3;
44283   arg4 = (float)jarg5;
44284   arg5 = (float)jarg4;
44285   {
44286     try {
44287       (arg1)->Set(arg2,arg3,arg4,arg5);
44288     } catch (std::out_of_range& e) {
44289       {
44290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44291       };
44292     } catch (std::exception& e) {
44293       {
44294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44295       };
44296     } catch (...) {
44297       {
44298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44299       };
44300     }
44301   }
44302 }
44303
44304
44305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
44306   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44307   float arg2 ;
44308
44309   arg1 = (Dali::Rect< float > *)jarg1;
44310   arg2 = (float)jarg2;
44311   if (arg1) (arg1)->left = arg2;
44312 }
44313
44314
44315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
44316   float jresult ;
44317   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44318   float result;
44319
44320   arg1 = (Dali::Rect< float > *)jarg1;
44321   result = (float) ((arg1)->left);
44322   jresult = result;
44323   return jresult;
44324 }
44325
44326
44327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
44328   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44329   float arg2 ;
44330
44331   arg1 = (Dali::Rect< float > *)jarg1;
44332   arg2 = (float)jarg2;
44333   if (arg1) (arg1)->left = arg2;
44334 }
44335
44336
44337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
44338   float jresult ;
44339   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44340   float result;
44341
44342   arg1 = (Dali::Rect< float > *)jarg1;
44343   result = (float) ((arg1)->left);
44344   jresult = result;
44345   return jresult;
44346 }
44347
44348
44349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
44350   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44351   float arg2 ;
44352
44353   arg1 = (Dali::Rect< float > *)jarg1;
44354   arg2 = (float)jarg2;
44355   if (arg1) (arg1)->right = arg2;
44356 }
44357
44358
44359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
44360   float jresult ;
44361   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44362   float result;
44363
44364   arg1 = (Dali::Rect< float > *)jarg1;
44365   result = (float) ((arg1)->right);
44366   jresult = result;
44367   return jresult;
44368 }
44369
44370
44371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
44372   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44373   float arg2 ;
44374
44375   arg1 = (Dali::Rect< float > *)jarg1;
44376   arg2 = (float)jarg2;
44377   if (arg1) (arg1)->right = arg2;
44378 }
44379
44380
44381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
44382   float jresult ;
44383   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44384   float result;
44385
44386   arg1 = (Dali::Rect< float > *)jarg1;
44387   result = (float) ((arg1)->right);
44388   jresult = result;
44389   return jresult;
44390 }
44391
44392
44393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
44394   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44395   float arg2 ;
44396
44397   arg1 = (Dali::Rect< float > *)jarg1;
44398   arg2 = (float)jarg2;
44399   if (arg1) (arg1)->bottom = arg2;
44400 }
44401
44402
44403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
44404   float jresult ;
44405   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44406   float result;
44407
44408   arg1 = (Dali::Rect< float > *)jarg1;
44409   result = (float) ((arg1)->bottom);
44410   jresult = result;
44411   return jresult;
44412 }
44413
44414
44415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
44416   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44417   float arg2 ;
44418
44419   arg1 = (Dali::Rect< float > *)jarg1;
44420   arg2 = (float)jarg2;
44421   if (arg1) (arg1)->top = arg2;
44422 }
44423
44424
44425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
44426   float jresult ;
44427   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44428   float result;
44429
44430   arg1 = (Dali::Rect< float > *)jarg1;
44431   result = (float) ((arg1)->top);
44432   jresult = result;
44433   return jresult;
44434 }
44435
44436
44437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
44438   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44439
44440   arg1 = (Dali::Rect< float > *)jarg1;
44441   {
44442     try {
44443       delete arg1;
44444     } catch (std::out_of_range& e) {
44445       {
44446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44447       };
44448     } catch (std::exception& e) {
44449       {
44450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44451       };
44452     } catch (...) {
44453       {
44454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44455       };
44456     }
44457   }
44458 }
44459
44460
44461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
44462   int jresult ;
44463   int result;
44464
44465   result = (int)Dali::Vector< int >::BaseType;
44466   jresult = (int)result;
44467   return jresult;
44468 }
44469
44470
44471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
44472   void * jresult ;
44473   Dali::Vector< int > *result = 0 ;
44474
44475   {
44476     try {
44477       result = (Dali::Vector< int > *)new Dali::Vector< int >();
44478     } catch (std::out_of_range& e) {
44479       {
44480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44481       };
44482     } catch (std::exception& e) {
44483       {
44484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44485       };
44486     } catch (...) {
44487       {
44488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44489       };
44490     }
44491   }
44492   jresult = (void *)result;
44493   return jresult;
44494 }
44495
44496
44497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
44498   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44499
44500   arg1 = (Dali::Vector< int > *)jarg1;
44501   {
44502     try {
44503       delete arg1;
44504     } catch (std::out_of_range& e) {
44505       {
44506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44507       };
44508     } catch (std::exception& e) {
44509       {
44510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44511       };
44512     } catch (...) {
44513       {
44514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44515       };
44516     }
44517   }
44518 }
44519
44520
44521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
44522   void * jresult ;
44523   Dali::Vector< int > *arg1 = 0 ;
44524   Dali::Vector< int > *result = 0 ;
44525
44526   arg1 = (Dali::Vector< int > *)jarg1;
44527   if (!arg1) {
44528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44529     return 0;
44530   }
44531   {
44532     try {
44533       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
44534     } catch (std::out_of_range& e) {
44535       {
44536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44537       };
44538     } catch (std::exception& e) {
44539       {
44540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44541       };
44542     } catch (...) {
44543       {
44544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44545       };
44546     }
44547   }
44548   jresult = (void *)result;
44549   return jresult;
44550 }
44551
44552
44553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
44554   void * jresult ;
44555   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44556   Dali::Vector< int > *arg2 = 0 ;
44557   Dali::Vector< int > *result = 0 ;
44558
44559   arg1 = (Dali::Vector< int > *)jarg1;
44560   arg2 = (Dali::Vector< int > *)jarg2;
44561   if (!arg2) {
44562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44563     return 0;
44564   }
44565   {
44566     try {
44567       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
44568     } catch (std::out_of_range& e) {
44569       {
44570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44571       };
44572     } catch (std::exception& e) {
44573       {
44574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44575       };
44576     } catch (...) {
44577       {
44578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44579       };
44580     }
44581   }
44582   jresult = (void *)result;
44583   return jresult;
44584 }
44585
44586
44587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
44588   void * jresult ;
44589   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44590   Dali::Vector< int >::Iterator result;
44591
44592   arg1 = (Dali::Vector< int > *)jarg1;
44593   {
44594     try {
44595       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
44596     } catch (std::out_of_range& e) {
44597       {
44598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44599       };
44600     } catch (std::exception& e) {
44601       {
44602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44603       };
44604     } catch (...) {
44605       {
44606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44607       };
44608     }
44609   }
44610   jresult = (void *)result;
44611   return jresult;
44612 }
44613
44614
44615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
44616   void * jresult ;
44617   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44618   Dali::Vector< int >::Iterator result;
44619
44620   arg1 = (Dali::Vector< int > *)jarg1;
44621   {
44622     try {
44623       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
44624     } catch (std::out_of_range& e) {
44625       {
44626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44627       };
44628     } catch (std::exception& e) {
44629       {
44630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44631       };
44632     } catch (...) {
44633       {
44634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44635       };
44636     }
44637   }
44638   jresult = (void *)result;
44639   return jresult;
44640 }
44641
44642
44643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
44644   void * jresult ;
44645   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44646   Dali::Vector< int >::SizeType arg2 ;
44647   Dali::Vector< int >::ItemType *result = 0 ;
44648
44649   arg1 = (Dali::Vector< int > *)jarg1;
44650   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44651   {
44652     try {
44653       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
44654     } catch (std::out_of_range& e) {
44655       {
44656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44657       };
44658     } catch (std::exception& e) {
44659       {
44660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44661       };
44662     } catch (...) {
44663       {
44664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44665       };
44666     }
44667   }
44668   jresult = (void *)result;
44669   return jresult;
44670 }
44671
44672
44673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
44674   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44675   Dali::Vector< int >::ItemType *arg2 = 0 ;
44676   Dali::Vector< int >::ItemType temp2 ;
44677
44678   arg1 = (Dali::Vector< int > *)jarg1;
44679   temp2 = (Dali::Vector< int >::ItemType)jarg2;
44680   arg2 = &temp2;
44681   {
44682     try {
44683       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
44684     } catch (std::out_of_range& e) {
44685       {
44686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44687       };
44688     } catch (std::exception& e) {
44689       {
44690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44691       };
44692     } catch (...) {
44693       {
44694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44695       };
44696     }
44697   }
44698 }
44699
44700
44701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
44702   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44703   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44704   Dali::Vector< int >::ItemType *arg3 = 0 ;
44705   Dali::Vector< int >::ItemType temp3 ;
44706
44707   arg1 = (Dali::Vector< int > *)jarg1;
44708   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44709   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44710   arg3 = &temp3;
44711   {
44712     try {
44713       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44714     } catch (std::out_of_range& e) {
44715       {
44716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44717       };
44718     } catch (std::exception& e) {
44719       {
44720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44721       };
44722     } catch (...) {
44723       {
44724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44725       };
44726     }
44727   }
44728 }
44729
44730
44731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44732   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44733   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44734   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44735   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
44736
44737   arg1 = (Dali::Vector< int > *)jarg1;
44738   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44739   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44740   arg4 = (Dali::Vector< int >::Iterator)jarg4;
44741   {
44742     try {
44743       (arg1)->Insert(arg2,arg3,arg4);
44744     } catch (std::out_of_range& e) {
44745       {
44746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44747       };
44748     } catch (std::exception& e) {
44749       {
44750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44751       };
44752     } catch (...) {
44753       {
44754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44755       };
44756     }
44757   }
44758 }
44759
44760
44761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
44762   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44763   Dali::Vector< int >::SizeType arg2 ;
44764
44765   arg1 = (Dali::Vector< int > *)jarg1;
44766   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44767   {
44768     try {
44769       (arg1)->Reserve(arg2);
44770     } catch (std::out_of_range& e) {
44771       {
44772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44773       };
44774     } catch (std::exception& e) {
44775       {
44776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44777       };
44778     } catch (...) {
44779       {
44780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44781       };
44782     }
44783   }
44784 }
44785
44786
44787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
44788   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44789   Dali::Vector< int >::SizeType arg2 ;
44790
44791   arg1 = (Dali::Vector< int > *)jarg1;
44792   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44793   {
44794     try {
44795       (arg1)->Resize(arg2);
44796     } catch (std::out_of_range& e) {
44797       {
44798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44799       };
44800     } catch (std::exception& e) {
44801       {
44802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44803       };
44804     } catch (...) {
44805       {
44806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44807       };
44808     }
44809   }
44810 }
44811
44812
44813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
44814   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44815   Dali::Vector< int >::SizeType arg2 ;
44816   Dali::Vector< int >::ItemType *arg3 = 0 ;
44817   Dali::Vector< int >::ItemType temp3 ;
44818
44819   arg1 = (Dali::Vector< int > *)jarg1;
44820   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44821   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44822   arg3 = &temp3;
44823   {
44824     try {
44825       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44826     } catch (std::out_of_range& e) {
44827       {
44828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44829       };
44830     } catch (std::exception& e) {
44831       {
44832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44833       };
44834     } catch (...) {
44835       {
44836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44837       };
44838     }
44839   }
44840 }
44841
44842
44843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
44844   void * jresult ;
44845   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44846   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44847   Dali::Vector< int >::Iterator result;
44848
44849   arg1 = (Dali::Vector< int > *)jarg1;
44850   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44851   {
44852     try {
44853       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
44854     } catch (std::out_of_range& e) {
44855       {
44856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44857       };
44858     } catch (std::exception& e) {
44859       {
44860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44861       };
44862     } catch (...) {
44863       {
44864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44865       };
44866     }
44867   }
44868   jresult = (void *)result;
44869   return jresult;
44870 }
44871
44872
44873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
44874   void * jresult ;
44875   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44876   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44877   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44878   Dali::Vector< int >::Iterator result;
44879
44880   arg1 = (Dali::Vector< int > *)jarg1;
44881   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44882   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44883   {
44884     try {
44885       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
44886     } catch (std::out_of_range& e) {
44887       {
44888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44889       };
44890     } catch (std::exception& e) {
44891       {
44892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44893       };
44894     } catch (...) {
44895       {
44896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44897       };
44898     }
44899   }
44900   jresult = (void *)result;
44901   return jresult;
44902 }
44903
44904
44905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
44906   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44907   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44908
44909   arg1 = (Dali::Vector< int > *)jarg1;
44910   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44911   {
44912     try {
44913       (arg1)->Remove(arg2);
44914     } catch (std::out_of_range& e) {
44915       {
44916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44917       };
44918     } catch (std::exception& e) {
44919       {
44920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44921       };
44922     } catch (...) {
44923       {
44924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44925       };
44926     }
44927   }
44928 }
44929
44930
44931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
44932   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44933   Dali::Vector< int > *arg2 = 0 ;
44934
44935   arg1 = (Dali::Vector< int > *)jarg1;
44936   arg2 = (Dali::Vector< int > *)jarg2;
44937   if (!arg2) {
44938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
44939     return ;
44940   }
44941   {
44942     try {
44943       (arg1)->Swap(*arg2);
44944     } catch (std::out_of_range& e) {
44945       {
44946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44947       };
44948     } catch (std::exception& e) {
44949       {
44950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44951       };
44952     } catch (...) {
44953       {
44954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44955       };
44956     }
44957   }
44958 }
44959
44960
44961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
44962   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44963
44964   arg1 = (Dali::Vector< int > *)jarg1;
44965   {
44966     try {
44967       (arg1)->Clear();
44968     } catch (std::out_of_range& e) {
44969       {
44970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44971       };
44972     } catch (std::exception& e) {
44973       {
44974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44975       };
44976     } catch (...) {
44977       {
44978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44979       };
44980     }
44981   }
44982 }
44983
44984
44985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
44986   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44987
44988   arg1 = (Dali::Vector< int > *)jarg1;
44989   {
44990     try {
44991       (arg1)->Release();
44992     } catch (std::out_of_range& e) {
44993       {
44994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44995       };
44996     } catch (std::exception& e) {
44997       {
44998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44999       };
45000     } catch (...) {
45001       {
45002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45003       };
45004     }
45005   }
45006 }
45007
45008
45009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
45010   int jresult ;
45011   int result;
45012
45013   result = (int)Dali::Vector< float >::BaseType;
45014   jresult = (int)result;
45015   return jresult;
45016 }
45017
45018
45019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
45020   void * jresult ;
45021   Dali::Vector< float > *result = 0 ;
45022
45023   {
45024     try {
45025       result = (Dali::Vector< float > *)new Dali::Vector< float >();
45026     } catch (std::out_of_range& e) {
45027       {
45028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45029       };
45030     } catch (std::exception& e) {
45031       {
45032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45033       };
45034     } catch (...) {
45035       {
45036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45037       };
45038     }
45039   }
45040   jresult = (void *)result;
45041   return jresult;
45042 }
45043
45044
45045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
45046   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45047
45048   arg1 = (Dali::Vector< float > *)jarg1;
45049   {
45050     try {
45051       delete arg1;
45052     } catch (std::out_of_range& e) {
45053       {
45054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45055       };
45056     } catch (std::exception& e) {
45057       {
45058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45059       };
45060     } catch (...) {
45061       {
45062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45063       };
45064     }
45065   }
45066 }
45067
45068
45069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
45070   void * jresult ;
45071   Dali::Vector< float > *arg1 = 0 ;
45072   Dali::Vector< float > *result = 0 ;
45073
45074   arg1 = (Dali::Vector< float > *)jarg1;
45075   if (!arg1) {
45076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45077     return 0;
45078   }
45079   {
45080     try {
45081       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
45082     } catch (std::out_of_range& e) {
45083       {
45084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45085       };
45086     } catch (std::exception& e) {
45087       {
45088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45089       };
45090     } catch (...) {
45091       {
45092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45093       };
45094     }
45095   }
45096   jresult = (void *)result;
45097   return jresult;
45098 }
45099
45100
45101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
45102   void * jresult ;
45103   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45104   Dali::Vector< float > *arg2 = 0 ;
45105   Dali::Vector< float > *result = 0 ;
45106
45107   arg1 = (Dali::Vector< float > *)jarg1;
45108   arg2 = (Dali::Vector< float > *)jarg2;
45109   if (!arg2) {
45110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45111     return 0;
45112   }
45113   {
45114     try {
45115       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
45116     } catch (std::out_of_range& e) {
45117       {
45118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45119       };
45120     } catch (std::exception& e) {
45121       {
45122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45123       };
45124     } catch (...) {
45125       {
45126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45127       };
45128     }
45129   }
45130   jresult = (void *)result;
45131   return jresult;
45132 }
45133
45134
45135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
45136   void * jresult ;
45137   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45138   Dali::Vector< float >::Iterator result;
45139
45140   arg1 = (Dali::Vector< float > *)jarg1;
45141   {
45142     try {
45143       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
45144     } catch (std::out_of_range& e) {
45145       {
45146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45147       };
45148     } catch (std::exception& e) {
45149       {
45150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45151       };
45152     } catch (...) {
45153       {
45154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45155       };
45156     }
45157   }
45158   jresult = (void *)result;
45159   return jresult;
45160 }
45161
45162
45163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
45164   void * jresult ;
45165   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45166   Dali::Vector< float >::Iterator result;
45167
45168   arg1 = (Dali::Vector< float > *)jarg1;
45169   {
45170     try {
45171       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
45172     } catch (std::out_of_range& e) {
45173       {
45174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45175       };
45176     } catch (std::exception& e) {
45177       {
45178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45179       };
45180     } catch (...) {
45181       {
45182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45183       };
45184     }
45185   }
45186   jresult = (void *)result;
45187   return jresult;
45188 }
45189
45190
45191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45192   void * jresult ;
45193   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45194   Dali::Vector< float >::SizeType arg2 ;
45195   Dali::Vector< float >::ItemType *result = 0 ;
45196
45197   arg1 = (Dali::Vector< float > *)jarg1;
45198   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45199   {
45200     try {
45201       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
45202     } catch (std::out_of_range& e) {
45203       {
45204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45205       };
45206     } catch (std::exception& e) {
45207       {
45208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45209       };
45210     } catch (...) {
45211       {
45212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45213       };
45214     }
45215   }
45216   jresult = (void *)result;
45217   return jresult;
45218 }
45219
45220
45221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
45222   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45223   Dali::Vector< float >::ItemType *arg2 = 0 ;
45224   Dali::Vector< float >::ItemType temp2 ;
45225
45226   arg1 = (Dali::Vector< float > *)jarg1;
45227   temp2 = (Dali::Vector< float >::ItemType)jarg2;
45228   arg2 = &temp2;
45229   {
45230     try {
45231       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
45232     } catch (std::out_of_range& e) {
45233       {
45234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45235       };
45236     } catch (std::exception& e) {
45237       {
45238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45239       };
45240     } catch (...) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45243       };
45244     }
45245   }
45246 }
45247
45248
45249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
45250   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45251   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45252   Dali::Vector< float >::ItemType *arg3 = 0 ;
45253   Dali::Vector< float >::ItemType temp3 ;
45254
45255   arg1 = (Dali::Vector< float > *)jarg1;
45256   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45257   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45258   arg3 = &temp3;
45259   {
45260     try {
45261       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45262     } catch (std::out_of_range& e) {
45263       {
45264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45265       };
45266     } catch (std::exception& e) {
45267       {
45268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45269       };
45270     } catch (...) {
45271       {
45272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45273       };
45274     }
45275   }
45276 }
45277
45278
45279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45280   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45281   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45282   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45283   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
45284
45285   arg1 = (Dali::Vector< float > *)jarg1;
45286   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45287   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45288   arg4 = (Dali::Vector< float >::Iterator)jarg4;
45289   {
45290     try {
45291       (arg1)->Insert(arg2,arg3,arg4);
45292     } catch (std::out_of_range& e) {
45293       {
45294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45295       };
45296     } catch (std::exception& e) {
45297       {
45298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45299       };
45300     } catch (...) {
45301       {
45302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45303       };
45304     }
45305   }
45306 }
45307
45308
45309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
45310   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45311   Dali::Vector< float >::SizeType arg2 ;
45312
45313   arg1 = (Dali::Vector< float > *)jarg1;
45314   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45315   {
45316     try {
45317       (arg1)->Reserve(arg2);
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_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45336   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45337   Dali::Vector< float >::SizeType arg2 ;
45338
45339   arg1 = (Dali::Vector< float > *)jarg1;
45340   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45341   {
45342     try {
45343       (arg1)->Resize(arg2);
45344     } catch (std::out_of_range& e) {
45345       {
45346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45347       };
45348     } catch (std::exception& e) {
45349       {
45350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45351       };
45352     } catch (...) {
45353       {
45354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45355       };
45356     }
45357   }
45358 }
45359
45360
45361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
45362   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45363   Dali::Vector< float >::SizeType arg2 ;
45364   Dali::Vector< float >::ItemType *arg3 = 0 ;
45365   Dali::Vector< float >::ItemType temp3 ;
45366
45367   arg1 = (Dali::Vector< float > *)jarg1;
45368   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45369   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45370   arg3 = &temp3;
45371   {
45372     try {
45373       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45374     } catch (std::out_of_range& e) {
45375       {
45376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45377       };
45378     } catch (std::exception& e) {
45379       {
45380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45381       };
45382     } catch (...) {
45383       {
45384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45385       };
45386     }
45387   }
45388 }
45389
45390
45391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
45392   void * jresult ;
45393   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45394   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45395   Dali::Vector< float >::Iterator result;
45396
45397   arg1 = (Dali::Vector< float > *)jarg1;
45398   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45399   {
45400     try {
45401       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
45402     } catch (std::out_of_range& e) {
45403       {
45404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45405       };
45406     } catch (std::exception& e) {
45407       {
45408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45409       };
45410     } catch (...) {
45411       {
45412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45413       };
45414     }
45415   }
45416   jresult = (void *)result;
45417   return jresult;
45418 }
45419
45420
45421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
45422   void * jresult ;
45423   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45424   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45425   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45426   Dali::Vector< float >::Iterator result;
45427
45428   arg1 = (Dali::Vector< float > *)jarg1;
45429   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45430   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45431   {
45432     try {
45433       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
45434     } catch (std::out_of_range& e) {
45435       {
45436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45437       };
45438     } catch (std::exception& e) {
45439       {
45440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45441       };
45442     } catch (...) {
45443       {
45444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45445       };
45446     }
45447   }
45448   jresult = (void *)result;
45449   return jresult;
45450 }
45451
45452
45453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
45454   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45455   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45456
45457   arg1 = (Dali::Vector< float > *)jarg1;
45458   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45459   {
45460     try {
45461       (arg1)->Remove(arg2);
45462     } catch (std::out_of_range& e) {
45463       {
45464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45465       };
45466     } catch (std::exception& e) {
45467       {
45468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45469       };
45470     } catch (...) {
45471       {
45472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45473       };
45474     }
45475   }
45476 }
45477
45478
45479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
45480   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45481   Dali::Vector< float > *arg2 = 0 ;
45482
45483   arg1 = (Dali::Vector< float > *)jarg1;
45484   arg2 = (Dali::Vector< float > *)jarg2;
45485   if (!arg2) {
45486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
45487     return ;
45488   }
45489   {
45490     try {
45491       (arg1)->Swap(*arg2);
45492     } catch (std::out_of_range& e) {
45493       {
45494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45495       };
45496     } catch (std::exception& e) {
45497       {
45498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45499       };
45500     } catch (...) {
45501       {
45502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45503       };
45504     }
45505   }
45506 }
45507
45508
45509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
45510   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45511
45512   arg1 = (Dali::Vector< float > *)jarg1;
45513   {
45514     try {
45515       (arg1)->Clear();
45516     } catch (std::out_of_range& e) {
45517       {
45518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45519       };
45520     } catch (std::exception& e) {
45521       {
45522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45523       };
45524     } catch (...) {
45525       {
45526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45527       };
45528     }
45529   }
45530 }
45531
45532
45533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
45534   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45535
45536   arg1 = (Dali::Vector< float > *)jarg1;
45537   {
45538     try {
45539       (arg1)->Release();
45540     } catch (std::out_of_range& e) {
45541       {
45542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45543       };
45544     } catch (std::exception& e) {
45545       {
45546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45547       };
45548     } catch (...) {
45549       {
45550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45551       };
45552     }
45553   }
45554 }
45555
45556
45557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
45558   int jresult ;
45559   int result;
45560
45561   result = (int)Dali::Vector< unsigned char >::BaseType;
45562   jresult = (int)result;
45563   return jresult;
45564 }
45565
45566
45567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
45568   void * jresult ;
45569   Dali::Vector< unsigned char > *result = 0 ;
45570
45571   {
45572     try {
45573       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
45574     } catch (std::out_of_range& e) {
45575       {
45576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45577       };
45578     } catch (std::exception& e) {
45579       {
45580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45581       };
45582     } catch (...) {
45583       {
45584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45585       };
45586     }
45587   }
45588   jresult = (void *)result;
45589   return jresult;
45590 }
45591
45592
45593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
45594   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45595
45596   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45597   {
45598     try {
45599       delete arg1;
45600     } catch (std::out_of_range& e) {
45601       {
45602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45603       };
45604     } catch (std::exception& e) {
45605       {
45606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45607       };
45608     } catch (...) {
45609       {
45610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45611       };
45612     }
45613   }
45614 }
45615
45616
45617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
45618   void * jresult ;
45619   Dali::Vector< unsigned char > *arg1 = 0 ;
45620   Dali::Vector< unsigned char > *result = 0 ;
45621
45622   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45623   if (!arg1) {
45624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45625     return 0;
45626   }
45627   {
45628     try {
45629       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
45630     } catch (std::out_of_range& e) {
45631       {
45632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45633       };
45634     } catch (std::exception& e) {
45635       {
45636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45637       };
45638     } catch (...) {
45639       {
45640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45641       };
45642     }
45643   }
45644   jresult = (void *)result;
45645   return jresult;
45646 }
45647
45648
45649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
45650   void * jresult ;
45651   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45652   Dali::Vector< unsigned char > *arg2 = 0 ;
45653   Dali::Vector< unsigned char > *result = 0 ;
45654
45655   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45656   arg2 = (Dali::Vector< unsigned char > *)jarg2;
45657   if (!arg2) {
45658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45659     return 0;
45660   }
45661   {
45662     try {
45663       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
45664     } catch (std::out_of_range& e) {
45665       {
45666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45667       };
45668     } catch (std::exception& e) {
45669       {
45670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45671       };
45672     } catch (...) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45675       };
45676     }
45677   }
45678   jresult = (void *)result;
45679   return jresult;
45680 }
45681
45682
45683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
45684   void * jresult ;
45685   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45686   Dali::Vector< unsigned char >::Iterator result;
45687
45688   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45689   {
45690     try {
45691       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
45692     } catch (std::out_of_range& e) {
45693       {
45694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45695       };
45696     } catch (std::exception& e) {
45697       {
45698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45699       };
45700     } catch (...) {
45701       {
45702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45703       };
45704     }
45705   }
45706   jresult = (void *)result;
45707   return jresult;
45708 }
45709
45710
45711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
45712   void * jresult ;
45713   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45714   Dali::Vector< unsigned char >::Iterator result;
45715
45716   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45717   {
45718     try {
45719       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
45720     } catch (std::out_of_range& e) {
45721       {
45722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45723       };
45724     } catch (std::exception& e) {
45725       {
45726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45727       };
45728     } catch (...) {
45729       {
45730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45731       };
45732     }
45733   }
45734   jresult = (void *)result;
45735   return jresult;
45736 }
45737
45738
45739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45740   void * jresult ;
45741   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45742   Dali::Vector< unsigned char >::SizeType arg2 ;
45743   Dali::Vector< unsigned char >::ItemType *result = 0 ;
45744
45745   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45746   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45747   {
45748     try {
45749       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
45750     } catch (std::out_of_range& e) {
45751       {
45752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45753       };
45754     } catch (std::exception& e) {
45755       {
45756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45757       };
45758     } catch (...) {
45759       {
45760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45761       };
45762     }
45763   }
45764   jresult = (void *)result;
45765   return jresult;
45766 }
45767
45768
45769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
45770   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45771   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
45772   Dali::Vector< unsigned char >::ItemType temp2 ;
45773
45774   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45775   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
45776   arg2 = &temp2;
45777   {
45778     try {
45779       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
45780     } catch (std::out_of_range& e) {
45781       {
45782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45783       };
45784     } catch (std::exception& e) {
45785       {
45786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45787       };
45788     } catch (...) {
45789       {
45790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45791       };
45792     }
45793   }
45794 }
45795
45796
45797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
45798   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45799   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45800   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45801   Dali::Vector< unsigned char >::ItemType temp3 ;
45802
45803   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45804   arg2 = jarg2;
45805   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45806   arg3 = &temp3;
45807   {
45808     try {
45809       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45810     } catch (std::out_of_range& e) {
45811       {
45812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45813       };
45814     } catch (std::exception& e) {
45815       {
45816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45817       };
45818     } catch (...) {
45819       {
45820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45821       };
45822     }
45823   }
45824
45825
45826 }
45827
45828
45829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
45830   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45831   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45832   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45833   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45834
45835   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45836   arg2 = jarg2;
45837   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45838   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
45839   {
45840     try {
45841       (arg1)->Insert(arg2,arg3,arg4);
45842     } catch (std::out_of_range& e) {
45843       {
45844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45845       };
45846     } catch (std::exception& e) {
45847       {
45848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45849       };
45850     } catch (...) {
45851       {
45852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45853       };
45854     }
45855   }
45856
45857
45858 }
45859
45860
45861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
45862   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45863   Dali::Vector< unsigned char >::SizeType arg2 ;
45864
45865   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45866   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45867   {
45868     try {
45869       (arg1)->Reserve(arg2);
45870     } catch (std::out_of_range& e) {
45871       {
45872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45873       };
45874     } catch (std::exception& e) {
45875       {
45876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45877       };
45878     } catch (...) {
45879       {
45880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45881       };
45882     }
45883   }
45884 }
45885
45886
45887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45888   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45889   Dali::Vector< unsigned char >::SizeType arg2 ;
45890
45891   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45892   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45893   {
45894     try {
45895       (arg1)->Resize(arg2);
45896     } catch (std::out_of_range& e) {
45897       {
45898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45899       };
45900     } catch (std::exception& e) {
45901       {
45902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45903       };
45904     } catch (...) {
45905       {
45906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45907       };
45908     }
45909   }
45910 }
45911
45912
45913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
45914   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45915   Dali::Vector< unsigned char >::SizeType arg2 ;
45916   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45917   Dali::Vector< unsigned char >::ItemType temp3 ;
45918
45919   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45920   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45921   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45922   arg3 = &temp3;
45923   {
45924     try {
45925       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45926     } catch (std::out_of_range& e) {
45927       {
45928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45929       };
45930     } catch (std::exception& e) {
45931       {
45932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45933       };
45934     } catch (...) {
45935       {
45936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45937       };
45938     }
45939   }
45940 }
45941
45942
45943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
45944   void * jresult ;
45945   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45946   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45947   Dali::Vector< unsigned char >::Iterator result;
45948
45949   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45950   arg2 = jarg2;
45951   {
45952     try {
45953       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
45954     } catch (std::out_of_range& e) {
45955       {
45956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45957       };
45958     } catch (std::exception& e) {
45959       {
45960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45961       };
45962     } catch (...) {
45963       {
45964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45965       };
45966     }
45967   }
45968   jresult = (void *)result;
45969
45970
45971   return jresult;
45972 }
45973
45974
45975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
45976   void * jresult ;
45977   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45978   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45979   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45980   Dali::Vector< unsigned char >::Iterator result;
45981
45982   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45983   arg2 = jarg2;
45984   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45985   {
45986     try {
45987       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
45988     } catch (std::out_of_range& e) {
45989       {
45990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45991       };
45992     } catch (std::exception& e) {
45993       {
45994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45995       };
45996     } catch (...) {
45997       {
45998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45999       };
46000     }
46001   }
46002   jresult = (void *)result;
46003
46004
46005   return jresult;
46006 }
46007
46008
46009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
46010   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46011   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
46012
46013   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46014   arg2 = jarg2;
46015   {
46016     try {
46017       (arg1)->Remove(arg2);
46018     } catch (std::out_of_range& e) {
46019       {
46020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46021       };
46022     } catch (std::exception& e) {
46023       {
46024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46025       };
46026     } catch (...) {
46027       {
46028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46029       };
46030     }
46031   }
46032
46033
46034 }
46035
46036
46037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
46038   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46039   Dali::Vector< unsigned char > *arg2 = 0 ;
46040
46041   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46042   arg2 = (Dali::Vector< unsigned char > *)jarg2;
46043   if (!arg2) {
46044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
46045     return ;
46046   }
46047   {
46048     try {
46049       (arg1)->Swap(*arg2);
46050     } catch (std::out_of_range& e) {
46051       {
46052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46053       };
46054     } catch (std::exception& e) {
46055       {
46056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46057       };
46058     } catch (...) {
46059       {
46060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46061       };
46062     }
46063   }
46064 }
46065
46066
46067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
46068   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46069
46070   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46071   {
46072     try {
46073       (arg1)->Clear();
46074     } catch (std::out_of_range& e) {
46075       {
46076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46077       };
46078     } catch (std::exception& e) {
46079       {
46080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46081       };
46082     } catch (...) {
46083       {
46084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46085       };
46086     }
46087   }
46088 }
46089
46090
46091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
46092   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46093
46094   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46095   {
46096     try {
46097       (arg1)->Release();
46098     } catch (std::out_of_range& e) {
46099       {
46100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46101       };
46102     } catch (std::exception& e) {
46103       {
46104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46105       };
46106     } catch (...) {
46107       {
46108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46109       };
46110     }
46111   }
46112 }
46113
46114
46115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
46116   int jresult ;
46117   int result;
46118
46119   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
46120   jresult = (int)result;
46121   return jresult;
46122 }
46123
46124
46125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
46126   void * jresult ;
46127   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46128
46129   {
46130     try {
46131       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
46132     } catch (std::out_of_range& e) {
46133       {
46134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46135       };
46136     } catch (std::exception& e) {
46137       {
46138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46139       };
46140     } catch (...) {
46141       {
46142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46143       };
46144     }
46145   }
46146   jresult = (void *)result;
46147   return jresult;
46148 }
46149
46150
46151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
46152   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46153
46154   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46155   {
46156     try {
46157       delete arg1;
46158     } catch (std::out_of_range& e) {
46159       {
46160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46161       };
46162     } catch (std::exception& e) {
46163       {
46164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46165       };
46166     } catch (...) {
46167       {
46168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46169       };
46170     }
46171   }
46172 }
46173
46174
46175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
46176   void * jresult ;
46177   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
46178   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46179
46180   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46181   if (!arg1) {
46182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46183     return 0;
46184   }
46185   {
46186     try {
46187       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
46188     } catch (std::out_of_range& e) {
46189       {
46190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46191       };
46192     } catch (std::exception& e) {
46193       {
46194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46195       };
46196     } catch (...) {
46197       {
46198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46199       };
46200     }
46201   }
46202   jresult = (void *)result;
46203   return jresult;
46204 }
46205
46206
46207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
46208   void * jresult ;
46209   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46210   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46211   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46212
46213   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46214   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46215   if (!arg2) {
46216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46217     return 0;
46218   }
46219   {
46220     try {
46221       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
46222     } catch (std::out_of_range& e) {
46223       {
46224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46225       };
46226     } catch (std::exception& e) {
46227       {
46228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46229       };
46230     } catch (...) {
46231       {
46232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46233       };
46234     }
46235   }
46236   jresult = (void *)result;
46237   return jresult;
46238 }
46239
46240
46241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
46242   void * jresult ;
46243   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46244   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46245
46246   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46247   {
46248     try {
46249       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
46250     } catch (std::out_of_range& e) {
46251       {
46252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46253       };
46254     } catch (std::exception& e) {
46255       {
46256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46257       };
46258     } catch (...) {
46259       {
46260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46261       };
46262     }
46263   }
46264   jresult = (void *)result;
46265   return jresult;
46266 }
46267
46268
46269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
46270   void * jresult ;
46271   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46272   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46273
46274   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46275   {
46276     try {
46277       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
46278     } catch (std::out_of_range& e) {
46279       {
46280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46281       };
46282     } catch (std::exception& e) {
46283       {
46284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46285       };
46286     } catch (...) {
46287       {
46288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46289       };
46290     }
46291   }
46292   jresult = (void *)result;
46293   return jresult;
46294 }
46295
46296
46297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46298   void * jresult ;
46299   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46300   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46301   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
46302
46303   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46304   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46305   {
46306     try {
46307       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
46308     } catch (std::out_of_range& e) {
46309       {
46310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46311       };
46312     } catch (std::exception& e) {
46313       {
46314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46315       };
46316     } catch (...) {
46317       {
46318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46319       };
46320     }
46321   }
46322   jresult = (void *)result;
46323   return jresult;
46324 }
46325
46326
46327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
46328   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46329   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
46330
46331   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46332   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
46333   if (!arg2) {
46334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46335     return ;
46336   }
46337   {
46338     try {
46339       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
46340     } catch (std::out_of_range& e) {
46341       {
46342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46343       };
46344     } catch (std::exception& e) {
46345       {
46346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46347       };
46348     } catch (...) {
46349       {
46350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46351       };
46352     }
46353   }
46354 }
46355
46356
46357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
46358   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46359   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46360   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46361
46362   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46363   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46364   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46365   if (!arg3) {
46366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46367     return ;
46368   }
46369   {
46370     try {
46371       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46372     } catch (std::out_of_range& e) {
46373       {
46374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46375       };
46376     } catch (std::exception& e) {
46377       {
46378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46379       };
46380     } catch (...) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46383       };
46384     }
46385   }
46386 }
46387
46388
46389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46390   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46391   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46392   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46393   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46394
46395   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46396   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46397   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46398   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
46399   {
46400     try {
46401       (arg1)->Insert(arg2,arg3,arg4);
46402     } catch (std::out_of_range& e) {
46403       {
46404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46405       };
46406     } catch (std::exception& e) {
46407       {
46408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46409       };
46410     } catch (...) {
46411       {
46412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46413       };
46414     }
46415   }
46416 }
46417
46418
46419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
46420   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46421   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46422
46423   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46424   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46425   {
46426     try {
46427       (arg1)->Reserve(arg2);
46428     } catch (std::out_of_range& e) {
46429       {
46430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46431       };
46432     } catch (std::exception& e) {
46433       {
46434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46435       };
46436     } catch (...) {
46437       {
46438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46439       };
46440     }
46441   }
46442 }
46443
46444
46445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46446   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46447   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46448
46449   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46450   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46451   {
46452     try {
46453       (arg1)->Resize(arg2);
46454     } catch (std::out_of_range& e) {
46455       {
46456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46457       };
46458     } catch (std::exception& e) {
46459       {
46460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46461       };
46462     } catch (...) {
46463       {
46464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46465       };
46466     }
46467   }
46468 }
46469
46470
46471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
46472   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46473   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46474   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46475
46476   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46477   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46478   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46479   if (!arg3) {
46480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46481     return ;
46482   }
46483   {
46484     try {
46485       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46486     } catch (std::out_of_range& e) {
46487       {
46488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46489       };
46490     } catch (std::exception& e) {
46491       {
46492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46493       };
46494     } catch (...) {
46495       {
46496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46497       };
46498     }
46499   }
46500 }
46501
46502
46503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
46504   void * jresult ;
46505   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46506   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46507   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46508
46509   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46510   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46511   {
46512     try {
46513       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
46514     } catch (std::out_of_range& e) {
46515       {
46516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46517       };
46518     } catch (std::exception& e) {
46519       {
46520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46521       };
46522     } catch (...) {
46523       {
46524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46525       };
46526     }
46527   }
46528   jresult = (void *)result;
46529   return jresult;
46530 }
46531
46532
46533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46534   void * jresult ;
46535   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46536   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46537   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46538   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46539
46540   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46541   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46542   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46543   {
46544     try {
46545       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
46546     } catch (std::out_of_range& e) {
46547       {
46548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46549       };
46550     } catch (std::exception& e) {
46551       {
46552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46553       };
46554     } catch (...) {
46555       {
46556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46557       };
46558     }
46559   }
46560   jresult = (void *)result;
46561   return jresult;
46562 }
46563
46564
46565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
46566   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46567   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46568
46569   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46570   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46571   {
46572     try {
46573       (arg1)->Remove(arg2);
46574     } catch (std::out_of_range& e) {
46575       {
46576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46577       };
46578     } catch (std::exception& e) {
46579       {
46580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46581       };
46582     } catch (...) {
46583       {
46584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46585       };
46586     }
46587   }
46588 }
46589
46590
46591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
46592   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46593   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46594
46595   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46596   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46597   if (!arg2) {
46598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
46599     return ;
46600   }
46601   {
46602     try {
46603       (arg1)->Swap(*arg2);
46604     } catch (std::out_of_range& e) {
46605       {
46606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46607       };
46608     } catch (std::exception& e) {
46609       {
46610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46611       };
46612     } catch (...) {
46613       {
46614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46615       };
46616     }
46617   }
46618 }
46619
46620
46621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
46622   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46623
46624   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46625   {
46626     try {
46627       (arg1)->Clear();
46628     } catch (std::out_of_range& e) {
46629       {
46630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46631       };
46632     } catch (std::exception& e) {
46633       {
46634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46635       };
46636     } catch (...) {
46637       {
46638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46639       };
46640     }
46641   }
46642 }
46643
46644
46645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
46646   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46647
46648   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46649   {
46650     try {
46651       (arg1)->Release();
46652     } catch (std::out_of_range& e) {
46653       {
46654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46655       };
46656     } catch (std::exception& e) {
46657       {
46658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46659       };
46660     } catch (...) {
46661       {
46662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46663       };
46664     }
46665   }
46666 }
46667
46668
46669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
46670   void * jresult ;
46671   Dali::Signal< void () > *result = 0 ;
46672
46673   {
46674     try {
46675       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
46676     } catch (std::out_of_range& e) {
46677       {
46678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46679       };
46680     } catch (std::exception& e) {
46681       {
46682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46683       };
46684     } catch (...) {
46685       {
46686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46687       };
46688     }
46689   }
46690   jresult = (void *)result;
46691   return jresult;
46692 }
46693
46694
46695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
46696   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46697
46698   arg1 = (Dali::Signal< void () > *)jarg1;
46699   {
46700     try {
46701       delete arg1;
46702     } catch (std::out_of_range& e) {
46703       {
46704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46705       };
46706     } catch (std::exception& e) {
46707       {
46708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46709       };
46710     } catch (...) {
46711       {
46712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46713       };
46714     }
46715   }
46716 }
46717
46718
46719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
46720   unsigned int jresult ;
46721   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46722   bool result;
46723
46724   arg1 = (Dali::Signal< void () > *)jarg1;
46725   {
46726     try {
46727       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
46728     } catch (std::out_of_range& e) {
46729       {
46730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46731       };
46732     } catch (std::exception& e) {
46733       {
46734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46735       };
46736     } catch (...) {
46737       {
46738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46739       };
46740     }
46741   }
46742   jresult = result;
46743   return jresult;
46744 }
46745
46746
46747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
46748   unsigned long jresult ;
46749   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46750   std::size_t result;
46751
46752   arg1 = (Dali::Signal< void () > *)jarg1;
46753   {
46754     try {
46755       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
46756     } catch (std::out_of_range& e) {
46757       {
46758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46759       };
46760     } catch (std::exception& e) {
46761       {
46762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46763       };
46764     } catch (...) {
46765       {
46766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46767       };
46768     }
46769   }
46770   jresult = (unsigned long)result;
46771   return jresult;
46772 }
46773
46774
46775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
46776   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46777   void (*arg2)() = (void (*)()) 0 ;
46778
46779   arg1 = (Dali::Signal< void () > *)jarg1;
46780   arg2 = (void (*)())jarg2;
46781   {
46782     try {
46783       (arg1)->Connect(arg2);
46784     } catch (std::out_of_range& e) {
46785       {
46786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46787       };
46788     } catch (std::exception& e) {
46789       {
46790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46791       };
46792     } catch (...) {
46793       {
46794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46795       };
46796     }
46797   }
46798 }
46799
46800
46801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
46802   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46803   void (*arg2)() = (void (*)()) 0 ;
46804
46805   arg1 = (Dali::Signal< void () > *)jarg1;
46806   arg2 = (void (*)())jarg2;
46807   {
46808     try {
46809       (arg1)->Disconnect(arg2);
46810     } catch (std::out_of_range& e) {
46811       {
46812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46813       };
46814     } catch (std::exception& e) {
46815       {
46816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46817       };
46818     } catch (...) {
46819       {
46820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46821       };
46822     }
46823   }
46824 }
46825
46826
46827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
46828   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46829   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
46830   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
46831
46832   arg1 = (Dali::Signal< void () > *)jarg1;
46833   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
46834   arg3 = (Dali::FunctorDelegate *)jarg3;
46835   {
46836     try {
46837       (arg1)->Connect(arg2,arg3);
46838     } catch (std::out_of_range& e) {
46839       {
46840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46841       };
46842     } catch (std::exception& e) {
46843       {
46844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46845       };
46846     } catch (...) {
46847       {
46848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46849       };
46850     }
46851   }
46852 }
46853
46854
46855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
46856   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46857
46858   arg1 = (Dali::Signal< void () > *)jarg1;
46859   {
46860     try {
46861       (arg1)->Emit();
46862     } catch (std::out_of_range& e) {
46863       {
46864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46865       };
46866     } catch (std::exception& e) {
46867       {
46868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46869       };
46870     } catch (...) {
46871       {
46872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46873       };
46874     }
46875   }
46876 }
46877
46878
46879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
46880   unsigned int jresult ;
46881   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46882   bool result;
46883
46884   arg1 = (Dali::Signal< void (float) > *)jarg1;
46885   {
46886     try {
46887       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
46888     } catch (std::out_of_range& e) {
46889       {
46890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46891       };
46892     } catch (std::exception& e) {
46893       {
46894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46895       };
46896     } catch (...) {
46897       {
46898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46899       };
46900     }
46901   }
46902   jresult = result;
46903   return jresult;
46904 }
46905
46906
46907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
46908   unsigned long jresult ;
46909   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46910   std::size_t result;
46911
46912   arg1 = (Dali::Signal< void (float) > *)jarg1;
46913   {
46914     try {
46915       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
46916     } catch (std::out_of_range& e) {
46917       {
46918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46919       };
46920     } catch (std::exception& e) {
46921       {
46922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46923       };
46924     } catch (...) {
46925       {
46926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46927       };
46928     }
46929   }
46930   jresult = (unsigned long)result;
46931   return jresult;
46932 }
46933
46934
46935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
46936   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46937   void (*arg2)(float) = (void (*)(float)) 0 ;
46938
46939   arg1 = (Dali::Signal< void (float) > *)jarg1;
46940   arg2 = (void (*)(float))jarg2;
46941   {
46942     try {
46943       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
46944     } catch (std::out_of_range& e) {
46945       {
46946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46947       };
46948     } catch (std::exception& e) {
46949       {
46950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46951       };
46952     } catch (...) {
46953       {
46954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46955       };
46956     }
46957   }
46958 }
46959
46960
46961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
46962   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46963   void (*arg2)(float) = (void (*)(float)) 0 ;
46964
46965   arg1 = (Dali::Signal< void (float) > *)jarg1;
46966   arg2 = (void (*)(float))jarg2;
46967   {
46968     try {
46969       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
46970     } catch (std::out_of_range& e) {
46971       {
46972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46973       };
46974     } catch (std::exception& e) {
46975       {
46976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46977       };
46978     } catch (...) {
46979       {
46980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46981       };
46982     }
46983   }
46984 }
46985
46986
46987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
46988   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46989   float arg2 ;
46990
46991   arg1 = (Dali::Signal< void (float) > *)jarg1;
46992   arg2 = (float)jarg2;
46993   {
46994     try {
46995       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
46996     } catch (std::out_of_range& e) {
46997       {
46998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46999       };
47000     } catch (std::exception& e) {
47001       {
47002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47003       };
47004     } catch (...) {
47005       {
47006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47007       };
47008     }
47009   }
47010 }
47011
47012
47013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
47014   void * jresult ;
47015   Dali::Signal< void (float) > *result = 0 ;
47016
47017   {
47018     try {
47019       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
47020     } catch (std::out_of_range& e) {
47021       {
47022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47023       };
47024     } catch (std::exception& e) {
47025       {
47026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47027       };
47028     } catch (...) {
47029       {
47030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47031       };
47032     }
47033   }
47034   jresult = (void *)result;
47035   return jresult;
47036 }
47037
47038
47039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
47040   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
47041
47042   arg1 = (Dali::Signal< void (float) > *)jarg1;
47043   {
47044     try {
47045       delete arg1;
47046     } catch (std::out_of_range& e) {
47047       {
47048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47049       };
47050     } catch (std::exception& e) {
47051       {
47052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47053       };
47054     } catch (...) {
47055       {
47056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47057       };
47058     }
47059   }
47060 }
47061
47062
47063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
47064   unsigned int jresult ;
47065   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47066   bool result;
47067
47068   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47069   {
47070     try {
47071       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47072     } catch (std::out_of_range& e) {
47073       {
47074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47075       };
47076     } catch (std::exception& e) {
47077       {
47078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47079       };
47080     } catch (...) {
47081       {
47082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47083       };
47084     }
47085   }
47086   jresult = result;
47087   return jresult;
47088 }
47089
47090
47091 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
47092   unsigned long jresult ;
47093   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47094   std::size_t result;
47095
47096   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47097   {
47098     try {
47099       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47100     } catch (std::out_of_range& e) {
47101       {
47102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47103       };
47104     } catch (std::exception& e) {
47105       {
47106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47107       };
47108     } catch (...) {
47109       {
47110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47111       };
47112     }
47113   }
47114   jresult = (unsigned long)result;
47115   return jresult;
47116 }
47117
47118
47119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
47120   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47121   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47122
47123   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47124   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47125   {
47126     try {
47127       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
47128     } catch (std::out_of_range& e) {
47129       {
47130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47131       };
47132     } catch (std::exception& e) {
47133       {
47134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47135       };
47136     } catch (...) {
47137       {
47138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47139       };
47140     }
47141   }
47142 }
47143
47144
47145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
47146   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47147   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47148
47149   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47150   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47151   {
47152     try {
47153       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
47154     } catch (std::out_of_range& e) {
47155       {
47156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47157       };
47158     } catch (std::exception& e) {
47159       {
47160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47161       };
47162     } catch (...) {
47163       {
47164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47165       };
47166     }
47167   }
47168 }
47169
47170
47171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
47172   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47173   Dali::BaseHandle arg2 ;
47174   Dali::BaseHandle *argp2 ;
47175
47176   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47177   argp2 = (Dali::BaseHandle *)jarg2;
47178   if (!argp2) {
47179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47180     return ;
47181   }
47182   arg2 = *argp2;
47183   {
47184     try {
47185       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
47186     } catch (std::out_of_range& e) {
47187       {
47188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47189       };
47190     } catch (std::exception& e) {
47191       {
47192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47193       };
47194     } catch (...) {
47195       {
47196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47197       };
47198     }
47199   }
47200 }
47201
47202
47203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
47204   void * jresult ;
47205   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
47206
47207   {
47208     try {
47209       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
47210     } catch (std::out_of_range& e) {
47211       {
47212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47213       };
47214     } catch (std::exception& e) {
47215       {
47216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47217       };
47218     } catch (...) {
47219       {
47220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47221       };
47222     }
47223   }
47224   jresult = (void *)result;
47225   return jresult;
47226 }
47227
47228
47229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
47230   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47231
47232   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47233   {
47234     try {
47235       delete arg1;
47236     } catch (std::out_of_range& e) {
47237       {
47238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47239       };
47240     } catch (std::exception& e) {
47241       {
47242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47243       };
47244     } catch (...) {
47245       {
47246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47247       };
47248     }
47249   }
47250 }
47251
47252
47253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
47254   unsigned int jresult ;
47255   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47256   bool result;
47257
47258   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47259   {
47260     try {
47261       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47262     } catch (std::out_of_range& e) {
47263       {
47264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47265       };
47266     } catch (std::exception& e) {
47267       {
47268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47269       };
47270     } catch (...) {
47271       {
47272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47273       };
47274     }
47275   }
47276   jresult = result;
47277   return jresult;
47278 }
47279
47280
47281 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
47282   unsigned long jresult ;
47283   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47284   std::size_t result;
47285
47286   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47287   {
47288     try {
47289       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47290     } catch (std::out_of_range& e) {
47291       {
47292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47293       };
47294     } catch (std::exception& e) {
47295       {
47296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47297       };
47298     } catch (...) {
47299       {
47300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47301       };
47302     }
47303   }
47304   jresult = (unsigned long)result;
47305   return jresult;
47306 }
47307
47308
47309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
47310   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47311   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47312
47313   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47314   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47315   {
47316     try {
47317       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
47318     } catch (std::out_of_range& e) {
47319       {
47320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47321       };
47322     } catch (std::exception& e) {
47323       {
47324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47325       };
47326     } catch (...) {
47327       {
47328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47329       };
47330     }
47331   }
47332 }
47333
47334
47335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
47336   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47337   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47338
47339   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47340   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47341   {
47342     try {
47343       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
47344     } catch (std::out_of_range& e) {
47345       {
47346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47347       };
47348     } catch (std::exception& e) {
47349       {
47350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47351       };
47352     } catch (...) {
47353       {
47354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47355       };
47356     }
47357   }
47358 }
47359
47360
47361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
47362   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47363   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
47364
47365   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47366   arg2 = (Dali::RefObject *)jarg2;
47367   {
47368     try {
47369       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
47370     } catch (std::out_of_range& e) {
47371       {
47372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47373       };
47374     } catch (std::exception& e) {
47375       {
47376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47377       };
47378     } catch (...) {
47379       {
47380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47381       };
47382     }
47383   }
47384 }
47385
47386
47387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
47388   void * jresult ;
47389   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
47390
47391   {
47392     try {
47393       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
47394     } catch (std::out_of_range& e) {
47395       {
47396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47397       };
47398     } catch (std::exception& e) {
47399       {
47400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47401       };
47402     } catch (...) {
47403       {
47404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47405       };
47406     }
47407   }
47408   jresult = (void *)result;
47409   return jresult;
47410 }
47411
47412
47413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
47414   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47415
47416   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47417   {
47418     try {
47419       delete arg1;
47420     } catch (std::out_of_range& e) {
47421       {
47422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47423       };
47424     } catch (std::exception& e) {
47425       {
47426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47427       };
47428     } catch (...) {
47429       {
47430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47431       };
47432     }
47433   }
47434 }
47435
47436
47437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
47438   unsigned int jresult ;
47439   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47440   bool result;
47441
47442   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47443   {
47444     try {
47445       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47446     } catch (std::out_of_range& e) {
47447       {
47448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47449       };
47450     } catch (std::exception& e) {
47451       {
47452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47453       };
47454     } catch (...) {
47455       {
47456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47457       };
47458     }
47459   }
47460   jresult = result;
47461   return jresult;
47462 }
47463
47464
47465 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
47466   unsigned long jresult ;
47467   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47468   std::size_t result;
47469
47470   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47471   {
47472     try {
47473       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47474     } catch (std::out_of_range& e) {
47475       {
47476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47477       };
47478     } catch (std::exception& e) {
47479       {
47480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47481       };
47482     } catch (...) {
47483       {
47484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47485       };
47486     }
47487   }
47488   jresult = (unsigned long)result;
47489   return jresult;
47490 }
47491
47492
47493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
47494   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47495   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47496
47497   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47498   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47499   {
47500     try {
47501       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
47502     } catch (std::out_of_range& e) {
47503       {
47504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47505       };
47506     } catch (std::exception& e) {
47507       {
47508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47509       };
47510     } catch (...) {
47511       {
47512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47513       };
47514     }
47515   }
47516 }
47517
47518
47519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
47520   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47521   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47522
47523   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47524   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47525   {
47526     try {
47527       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
47528     } catch (std::out_of_range& e) {
47529       {
47530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47531       };
47532     } catch (std::exception& e) {
47533       {
47534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47535       };
47536     } catch (...) {
47537       {
47538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47539       };
47540     }
47541   }
47542 }
47543
47544
47545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
47546   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47547   Dali::PropertyNotification *arg2 = 0 ;
47548
47549   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47550   arg2 = (Dali::PropertyNotification *)jarg2;
47551   if (!arg2) {
47552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
47553     return ;
47554   }
47555   {
47556     try {
47557       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
47558     } catch (std::out_of_range& e) {
47559       {
47560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47561       };
47562     } catch (std::exception& e) {
47563       {
47564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47565       };
47566     } catch (...) {
47567       {
47568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47569       };
47570     }
47571   }
47572 }
47573
47574
47575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
47576   void * jresult ;
47577   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
47578
47579   {
47580     try {
47581       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
47582     } catch (std::out_of_range& e) {
47583       {
47584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47585       };
47586     } catch (std::exception& e) {
47587       {
47588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47589       };
47590     } catch (...) {
47591       {
47592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47593       };
47594     }
47595   }
47596   jresult = (void *)result;
47597   return jresult;
47598 }
47599
47600
47601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
47602   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47603
47604   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47605   {
47606     try {
47607       delete arg1;
47608     } catch (std::out_of_range& e) {
47609       {
47610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47611       };
47612     } catch (std::exception& e) {
47613       {
47614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47615       };
47616     } catch (...) {
47617       {
47618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47619       };
47620     }
47621   }
47622 }
47623
47624
47625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
47626   unsigned int jresult ;
47627   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47628   bool result;
47629
47630   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47631   {
47632     try {
47633       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
47634     } catch (std::out_of_range& e) {
47635       {
47636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47637       };
47638     } catch (std::exception& e) {
47639       {
47640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47641       };
47642     } catch (...) {
47643       {
47644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47645       };
47646     }
47647   }
47648   jresult = result;
47649   return jresult;
47650 }
47651
47652
47653 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
47654   unsigned long jresult ;
47655   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47656   std::size_t result;
47657
47658   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47659   {
47660     try {
47661       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
47662     } catch (std::out_of_range& e) {
47663       {
47664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47665       };
47666     } catch (std::exception& e) {
47667       {
47668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47669       };
47670     } catch (...) {
47671       {
47672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47673       };
47674     }
47675   }
47676   jresult = (unsigned long)result;
47677   return jresult;
47678 }
47679
47680
47681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
47682   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47683   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47684
47685   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47686   arg2 = (void (*)(Dali::Image))jarg2;
47687   {
47688     try {
47689       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
47690     } catch (std::out_of_range& e) {
47691       {
47692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47693       };
47694     } catch (std::exception& e) {
47695       {
47696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47697       };
47698     } catch (...) {
47699       {
47700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47701       };
47702     }
47703   }
47704 }
47705
47706
47707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
47708   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47709   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47710
47711   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47712   arg2 = (void (*)(Dali::Image))jarg2;
47713   {
47714     try {
47715       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
47716     } catch (std::out_of_range& e) {
47717       {
47718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47719       };
47720     } catch (std::exception& e) {
47721       {
47722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47723       };
47724     } catch (...) {
47725       {
47726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47727       };
47728     }
47729   }
47730 }
47731
47732
47733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
47734   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47735   Dali::Image arg2 ;
47736   Dali::Image *argp2 ;
47737
47738   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47739   argp2 = (Dali::Image *)jarg2;
47740   if (!argp2) {
47741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
47742     return ;
47743   }
47744   arg2 = *argp2;
47745   {
47746     try {
47747       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
47748     } catch (std::out_of_range& e) {
47749       {
47750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47751       };
47752     } catch (std::exception& e) {
47753       {
47754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47755       };
47756     } catch (...) {
47757       {
47758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47759       };
47760     }
47761   }
47762 }
47763
47764
47765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
47766   void * jresult ;
47767   Dali::Signal< void (Dali::Image) > *result = 0 ;
47768
47769   {
47770     try {
47771       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
47772     } catch (std::out_of_range& e) {
47773       {
47774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47775       };
47776     } catch (std::exception& e) {
47777       {
47778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47779       };
47780     } catch (...) {
47781       {
47782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47783       };
47784     }
47785   }
47786   jresult = (void *)result;
47787   return jresult;
47788 }
47789
47790
47791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
47792   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47793
47794   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47795   {
47796     try {
47797       delete arg1;
47798     } catch (std::out_of_range& e) {
47799       {
47800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47801       };
47802     } catch (std::exception& e) {
47803       {
47804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47805       };
47806     } catch (...) {
47807       {
47808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47809       };
47810     }
47811   }
47812 }
47813
47814
47815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
47816   void * jresult ;
47817   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
47818
47819   {
47820     try {
47821       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
47822     } catch (std::out_of_range& e) {
47823       {
47824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47825       };
47826     } catch (std::exception& e) {
47827       {
47828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47829       };
47830     } catch (...) {
47831       {
47832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47833       };
47834     }
47835   }
47836   jresult = (void *)result;
47837   return jresult;
47838 }
47839
47840
47841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
47842   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
47843
47844   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
47845   {
47846     try {
47847       delete arg1;
47848     } catch (std::out_of_range& e) {
47849       {
47850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47851       };
47852     } catch (std::exception& e) {
47853       {
47854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47855       };
47856     } catch (...) {
47857       {
47858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47859       };
47860     }
47861   }
47862 }
47863
47864
47865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
47866   unsigned int jresult ;
47867   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47868   bool result;
47869
47870   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47871   {
47872     try {
47873       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);
47874     } catch (std::out_of_range& e) {
47875       {
47876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47877       };
47878     } catch (std::exception& e) {
47879       {
47880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47881       };
47882     } catch (...) {
47883       {
47884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47885       };
47886     }
47887   }
47888   jresult = result;
47889   return jresult;
47890 }
47891
47892
47893 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
47894   unsigned long jresult ;
47895   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47896   std::size_t result;
47897
47898   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47899   {
47900     try {
47901       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);
47902     } catch (std::out_of_range& e) {
47903       {
47904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47905       };
47906     } catch (std::exception& e) {
47907       {
47908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47909       };
47910     } catch (...) {
47911       {
47912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47913       };
47914     }
47915   }
47916   jresult = (unsigned long)result;
47917   return jresult;
47918 }
47919
47920
47921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
47922   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47923   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47924
47925   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47926   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47927   {
47928     try {
47929       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
47930     } catch (std::out_of_range& e) {
47931       {
47932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47933       };
47934     } catch (std::exception& e) {
47935       {
47936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47937       };
47938     } catch (...) {
47939       {
47940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47941       };
47942     }
47943   }
47944 }
47945
47946
47947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
47948   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47949   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47950
47951   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47952   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47953   {
47954     try {
47955       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
47956     } catch (std::out_of_range& e) {
47957       {
47958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47959       };
47960     } catch (std::exception& e) {
47961       {
47962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47963       };
47964     } catch (...) {
47965       {
47966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47967       };
47968     }
47969   }
47970 }
47971
47972
47973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
47974   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47975   Dali::Actor arg2 ;
47976   Dali::LongPressGesture *arg3 = 0 ;
47977   Dali::Actor *argp2 ;
47978
47979   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47980   argp2 = (Dali::Actor *)jarg2;
47981   if (!argp2) {
47982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47983     return ;
47984   }
47985   arg2 = *argp2;
47986   arg3 = (Dali::LongPressGesture *)jarg3;
47987   if (!arg3) {
47988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
47989     return ;
47990   }
47991   {
47992     try {
47993       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
47994     } catch (std::out_of_range& e) {
47995       {
47996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47997       };
47998     } catch (std::exception& e) {
47999       {
48000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48001       };
48002     } catch (...) {
48003       {
48004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48005       };
48006     }
48007   }
48008 }
48009
48010
48011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
48012   void * jresult ;
48013   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
48014
48015   {
48016     try {
48017       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
48018     } catch (std::out_of_range& e) {
48019       {
48020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48021       };
48022     } catch (std::exception& e) {
48023       {
48024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48025       };
48026     } catch (...) {
48027       {
48028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48029       };
48030     }
48031   }
48032   jresult = (void *)result;
48033   return jresult;
48034 }
48035
48036
48037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
48038   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
48039
48040   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
48041   {
48042     try {
48043       delete arg1;
48044     } catch (std::out_of_range& e) {
48045       {
48046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48047       };
48048     } catch (std::exception& e) {
48049       {
48050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48051       };
48052     } catch (...) {
48053       {
48054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48055       };
48056     }
48057   }
48058 }
48059
48060
48061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
48062   unsigned int jresult ;
48063   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48064   bool result;
48065
48066   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48067   {
48068     try {
48069       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);
48070     } catch (std::out_of_range& e) {
48071       {
48072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48073       };
48074     } catch (std::exception& e) {
48075       {
48076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48077       };
48078     } catch (...) {
48079       {
48080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48081       };
48082     }
48083   }
48084   jresult = result;
48085   return jresult;
48086 }
48087
48088
48089 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
48090   unsigned long jresult ;
48091   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48092   std::size_t result;
48093
48094   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48095   {
48096     try {
48097       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);
48098     } catch (std::out_of_range& e) {
48099       {
48100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48101       };
48102     } catch (std::exception& e) {
48103       {
48104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48105       };
48106     } catch (...) {
48107       {
48108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48109       };
48110     }
48111   }
48112   jresult = (unsigned long)result;
48113   return jresult;
48114 }
48115
48116
48117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
48118   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48119   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48120
48121   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48122   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48123   {
48124     try {
48125       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48126     } catch (std::out_of_range& e) {
48127       {
48128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48129       };
48130     } catch (std::exception& e) {
48131       {
48132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48133       };
48134     } catch (...) {
48135       {
48136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48137       };
48138     }
48139   }
48140 }
48141
48142
48143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
48144   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48145   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48146
48147   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48148   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48149   {
48150     try {
48151       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48152     } catch (std::out_of_range& e) {
48153       {
48154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48155       };
48156     } catch (std::exception& e) {
48157       {
48158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48159       };
48160     } catch (...) {
48161       {
48162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48163       };
48164     }
48165   }
48166 }
48167
48168
48169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48170   unsigned int jresult ;
48171   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48172   Dali::Actor arg2 ;
48173   Dali::TouchData *arg3 = 0 ;
48174   Dali::Actor *argp2 ;
48175   bool result;
48176
48177   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48178   argp2 = (Dali::Actor *)jarg2;
48179   if (!argp2) {
48180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48181     return 0;
48182   }
48183   arg2 = *argp2;
48184   arg3 = (Dali::TouchData *)jarg3;
48185   if (!arg3) {
48186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
48187     return 0;
48188   }
48189   {
48190     try {
48191       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
48192     } catch (std::out_of_range& e) {
48193       {
48194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48195       };
48196     } catch (std::exception& e) {
48197       {
48198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48199       };
48200     } catch (...) {
48201       {
48202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48203       };
48204     }
48205   }
48206   jresult = result;
48207   return jresult;
48208 }
48209
48210
48211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
48212   void * jresult ;
48213   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
48214
48215   {
48216     try {
48217       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
48218     } catch (std::out_of_range& e) {
48219       {
48220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48221       };
48222     } catch (std::exception& e) {
48223       {
48224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48225       };
48226     } catch (...) {
48227       {
48228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48229       };
48230     }
48231   }
48232   jresult = (void *)result;
48233   return jresult;
48234 }
48235
48236
48237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
48238   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48239
48240   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48241   {
48242     try {
48243       delete arg1;
48244     } catch (std::out_of_range& e) {
48245       {
48246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48247       };
48248     } catch (std::exception& e) {
48249       {
48250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48251       };
48252     } catch (...) {
48253       {
48254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48255       };
48256     }
48257   }
48258 }
48259
48260
48261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
48262   unsigned int jresult ;
48263   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48264   bool result;
48265
48266   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48267   {
48268     try {
48269       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);
48270     } catch (std::out_of_range& e) {
48271       {
48272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48273       };
48274     } catch (std::exception& e) {
48275       {
48276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48277       };
48278     } catch (...) {
48279       {
48280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48281       };
48282     }
48283   }
48284   jresult = result;
48285   return jresult;
48286 }
48287
48288
48289 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
48290   unsigned long jresult ;
48291   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48292   std::size_t result;
48293
48294   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48295   {
48296     try {
48297       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);
48298     } catch (std::out_of_range& e) {
48299       {
48300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48301       };
48302     } catch (std::exception& e) {
48303       {
48304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48305       };
48306     } catch (...) {
48307       {
48308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48309       };
48310     }
48311   }
48312   jresult = (unsigned long)result;
48313   return jresult;
48314 }
48315
48316
48317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
48318   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48319   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48320
48321   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48322   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48323   {
48324     try {
48325       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48326     } catch (std::out_of_range& e) {
48327       {
48328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48329       };
48330     } catch (std::exception& e) {
48331       {
48332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48333       };
48334     } catch (...) {
48335       {
48336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48337       };
48338     }
48339   }
48340 }
48341
48342
48343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
48344   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48345   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48346
48347   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48348   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48349   {
48350     try {
48351       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48352     } catch (std::out_of_range& e) {
48353       {
48354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48355       };
48356     } catch (std::exception& e) {
48357       {
48358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48359       };
48360     } catch (...) {
48361       {
48362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48363       };
48364     }
48365   }
48366 }
48367
48368
48369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48370   unsigned int jresult ;
48371   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48372   Dali::Actor arg2 ;
48373   Dali::HoverEvent *arg3 = 0 ;
48374   Dali::Actor *argp2 ;
48375   bool result;
48376
48377   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48378   argp2 = (Dali::Actor *)jarg2;
48379   if (!argp2) {
48380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48381     return 0;
48382   }
48383   arg2 = *argp2;
48384   arg3 = (Dali::HoverEvent *)jarg3;
48385   if (!arg3) {
48386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
48387     return 0;
48388   }
48389   {
48390     try {
48391       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
48392     } catch (std::out_of_range& e) {
48393       {
48394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48395       };
48396     } catch (std::exception& e) {
48397       {
48398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48399       };
48400     } catch (...) {
48401       {
48402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48403       };
48404     }
48405   }
48406   jresult = result;
48407   return jresult;
48408 }
48409
48410
48411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
48412   void * jresult ;
48413   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
48414
48415   {
48416     try {
48417       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
48418     } catch (std::out_of_range& e) {
48419       {
48420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48421       };
48422     } catch (std::exception& e) {
48423       {
48424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48425       };
48426     } catch (...) {
48427       {
48428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48429       };
48430     }
48431   }
48432   jresult = (void *)result;
48433   return jresult;
48434 }
48435
48436
48437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
48438   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48439
48440   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48441   {
48442     try {
48443       delete arg1;
48444     } catch (std::out_of_range& e) {
48445       {
48446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48447       };
48448     } catch (std::exception& e) {
48449       {
48450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48451       };
48452     } catch (...) {
48453       {
48454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48455       };
48456     }
48457   }
48458 }
48459
48460
48461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
48462   unsigned int jresult ;
48463   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48464   bool result;
48465
48466   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48467   {
48468     try {
48469       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);
48470     } catch (std::out_of_range& e) {
48471       {
48472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48473       };
48474     } catch (std::exception& e) {
48475       {
48476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48477       };
48478     } catch (...) {
48479       {
48480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48481       };
48482     }
48483   }
48484   jresult = result;
48485   return jresult;
48486 }
48487
48488
48489 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
48490   unsigned long jresult ;
48491   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48492   std::size_t result;
48493
48494   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48495   {
48496     try {
48497       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);
48498     } catch (std::out_of_range& e) {
48499       {
48500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48501       };
48502     } catch (std::exception& e) {
48503       {
48504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48505       };
48506     } catch (...) {
48507       {
48508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48509       };
48510     }
48511   }
48512   jresult = (unsigned long)result;
48513   return jresult;
48514 }
48515
48516
48517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
48518   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48519   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48520
48521   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48522   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48523   {
48524     try {
48525       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48526     } catch (std::out_of_range& e) {
48527       {
48528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48529       };
48530     } catch (std::exception& e) {
48531       {
48532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48533       };
48534     } catch (...) {
48535       {
48536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48537       };
48538     }
48539   }
48540 }
48541
48542
48543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
48544   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48545   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48546
48547   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48548   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48549   {
48550     try {
48551       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48552     } catch (std::out_of_range& e) {
48553       {
48554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48555       };
48556     } catch (std::exception& e) {
48557       {
48558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48559       };
48560     } catch (...) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48563       };
48564     }
48565   }
48566 }
48567
48568
48569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48570   unsigned int jresult ;
48571   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48572   Dali::Actor arg2 ;
48573   Dali::WheelEvent *arg3 = 0 ;
48574   Dali::Actor *argp2 ;
48575   bool result;
48576
48577   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48578   argp2 = (Dali::Actor *)jarg2;
48579   if (!argp2) {
48580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48581     return 0;
48582   }
48583   arg2 = *argp2;
48584   arg3 = (Dali::WheelEvent *)jarg3;
48585   if (!arg3) {
48586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
48587     return 0;
48588   }
48589   {
48590     try {
48591       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
48592     } catch (std::out_of_range& e) {
48593       {
48594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48595       };
48596     } catch (std::exception& e) {
48597       {
48598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48599       };
48600     } catch (...) {
48601       {
48602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48603       };
48604     }
48605   }
48606   jresult = result;
48607   return jresult;
48608 }
48609
48610
48611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
48612   void * jresult ;
48613   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
48614
48615   {
48616     try {
48617       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
48618     } catch (std::out_of_range& e) {
48619       {
48620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48621       };
48622     } catch (std::exception& e) {
48623       {
48624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48625       };
48626     } catch (...) {
48627       {
48628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48629       };
48630     }
48631   }
48632   jresult = (void *)result;
48633   return jresult;
48634 }
48635
48636
48637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
48638   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48639
48640   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48641   {
48642     try {
48643       delete arg1;
48644     } catch (std::out_of_range& e) {
48645       {
48646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (std::exception& e) {
48649       {
48650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48651       };
48652     } catch (...) {
48653       {
48654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48655       };
48656     }
48657   }
48658 }
48659
48660
48661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
48662   unsigned int jresult ;
48663   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48664   bool result;
48665
48666   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48667   {
48668     try {
48669       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
48670     } catch (std::out_of_range& e) {
48671       {
48672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48673       };
48674     } catch (std::exception& e) {
48675       {
48676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48677       };
48678     } catch (...) {
48679       {
48680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48681       };
48682     }
48683   }
48684   jresult = result;
48685   return jresult;
48686 }
48687
48688
48689 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
48690   unsigned long jresult ;
48691   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48692   std::size_t result;
48693
48694   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48695   {
48696     try {
48697       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
48698     } catch (std::out_of_range& e) {
48699       {
48700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48701       };
48702     } catch (std::exception& e) {
48703       {
48704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48705       };
48706     } catch (...) {
48707       {
48708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48709       };
48710     }
48711   }
48712   jresult = (unsigned long)result;
48713   return jresult;
48714 }
48715
48716
48717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
48718   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48719   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48720
48721   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48722   arg2 = (void (*)(Dali::Actor))jarg2;
48723   {
48724     try {
48725       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
48726     } catch (std::out_of_range& e) {
48727       {
48728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48729       };
48730     } catch (std::exception& e) {
48731       {
48732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48733       };
48734     } catch (...) {
48735       {
48736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48737       };
48738     }
48739   }
48740 }
48741
48742
48743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
48744   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48745   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48746
48747   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48748   arg2 = (void (*)(Dali::Actor))jarg2;
48749   {
48750     try {
48751       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
48752     } catch (std::out_of_range& e) {
48753       {
48754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48755       };
48756     } catch (std::exception& e) {
48757       {
48758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48759       };
48760     } catch (...) {
48761       {
48762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48763       };
48764     }
48765   }
48766 }
48767
48768
48769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
48770   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48771   Dali::Actor arg2 ;
48772   Dali::Actor *argp2 ;
48773
48774   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48775   argp2 = (Dali::Actor *)jarg2;
48776   if (!argp2) {
48777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48778     return ;
48779   }
48780   arg2 = *argp2;
48781   {
48782     try {
48783       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
48784     } catch (std::out_of_range& e) {
48785       {
48786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48787       };
48788     } catch (std::exception& e) {
48789       {
48790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48791       };
48792     } catch (...) {
48793       {
48794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48795       };
48796     }
48797   }
48798 }
48799
48800
48801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
48802   void * jresult ;
48803   Dali::Signal< void (Dali::Actor) > *result = 0 ;
48804
48805   {
48806     try {
48807       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
48808     } catch (std::out_of_range& e) {
48809       {
48810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48811       };
48812     } catch (std::exception& e) {
48813       {
48814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48815       };
48816     } catch (...) {
48817       {
48818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48819       };
48820     }
48821   }
48822   jresult = (void *)result;
48823   return jresult;
48824 }
48825
48826
48827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
48828   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48829
48830   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48831   {
48832     try {
48833       delete arg1;
48834     } catch (std::out_of_range& e) {
48835       {
48836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48837       };
48838     } catch (std::exception& e) {
48839       {
48840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48841       };
48842     } catch (...) {
48843       {
48844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48845       };
48846     }
48847   }
48848 }
48849
48850
48851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
48852   unsigned int jresult ;
48853   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48854   bool result;
48855
48856   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48857   {
48858     try {
48859       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48860     } catch (std::out_of_range& e) {
48861       {
48862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48863       };
48864     } catch (std::exception& e) {
48865       {
48866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48867       };
48868     } catch (...) {
48869       {
48870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48871       };
48872     }
48873   }
48874   jresult = result;
48875   return jresult;
48876 }
48877
48878
48879 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
48880   unsigned long jresult ;
48881   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48882   std::size_t result;
48883
48884   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48885   {
48886     try {
48887       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48888     } catch (std::out_of_range& e) {
48889       {
48890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48891       };
48892     } catch (std::exception& e) {
48893       {
48894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48895       };
48896     } catch (...) {
48897       {
48898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48899       };
48900     }
48901   }
48902   jresult = (unsigned long)result;
48903   return jresult;
48904 }
48905
48906
48907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
48908   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48909   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48910
48911   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48912   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48913   {
48914     try {
48915       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48916     } catch (std::out_of_range& e) {
48917       {
48918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48919       };
48920     } catch (std::exception& e) {
48921       {
48922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48923       };
48924     } catch (...) {
48925       {
48926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48927       };
48928     }
48929   }
48930 }
48931
48932
48933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
48934   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48935   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48936
48937   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48938   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48939   {
48940     try {
48941       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48942     } catch (std::out_of_range& e) {
48943       {
48944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48945       };
48946     } catch (std::exception& e) {
48947       {
48948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48949       };
48950     } catch (...) {
48951       {
48952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48953       };
48954     }
48955   }
48956 }
48957
48958
48959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
48960   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48961   Dali::KeyEvent *arg2 = 0 ;
48962
48963   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48964   arg2 = (Dali::KeyEvent *)jarg2;
48965   if (!arg2) {
48966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
48967     return ;
48968   }
48969   {
48970     try {
48971       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
48972     } catch (std::out_of_range& e) {
48973       {
48974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48975       };
48976     } catch (std::exception& e) {
48977       {
48978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48979       };
48980     } catch (...) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48983       };
48984     }
48985   }
48986 }
48987
48988
48989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
48990   void * jresult ;
48991   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
48992
48993   {
48994     try {
48995       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
48996     } catch (std::out_of_range& e) {
48997       {
48998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48999       };
49000     } catch (std::exception& e) {
49001       {
49002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49003       };
49004     } catch (...) {
49005       {
49006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49007       };
49008     }
49009   }
49010   jresult = (void *)result;
49011   return jresult;
49012 }
49013
49014
49015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
49016   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
49017
49018   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
49019   {
49020     try {
49021       delete arg1;
49022     } catch (std::out_of_range& e) {
49023       {
49024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49025       };
49026     } catch (std::exception& e) {
49027       {
49028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49029       };
49030     } catch (...) {
49031       {
49032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49033       };
49034     }
49035   }
49036 }
49037
49038
49039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
49040   unsigned int jresult ;
49041   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49042   bool result;
49043
49044   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49045   {
49046     try {
49047       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49048     } catch (std::out_of_range& e) {
49049       {
49050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49051       };
49052     } catch (std::exception& e) {
49053       {
49054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49055       };
49056     } catch (...) {
49057       {
49058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49059       };
49060     }
49061   }
49062   jresult = result;
49063   return jresult;
49064 }
49065
49066
49067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
49068   unsigned long jresult ;
49069   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49070   std::size_t result;
49071
49072   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49073   {
49074     try {
49075       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49076     } catch (std::out_of_range& e) {
49077       {
49078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49079       };
49080     } catch (std::exception& e) {
49081       {
49082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49083       };
49084     } catch (...) {
49085       {
49086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49087       };
49088     }
49089   }
49090   jresult = (unsigned long)result;
49091   return jresult;
49092 }
49093
49094
49095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
49096   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49097   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49098
49099   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49100   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49101   {
49102     try {
49103       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49104     } catch (std::out_of_range& e) {
49105       {
49106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49107       };
49108     } catch (std::exception& e) {
49109       {
49110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49111       };
49112     } catch (...) {
49113       {
49114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49115       };
49116     }
49117   }
49118 }
49119
49120
49121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
49122   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49123   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49124
49125   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49126   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49127   {
49128     try {
49129       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49130     } catch (std::out_of_range& e) {
49131       {
49132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49133       };
49134     } catch (std::exception& e) {
49135       {
49136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49137       };
49138     } catch (...) {
49139       {
49140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49141       };
49142     }
49143   }
49144 }
49145
49146
49147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
49148   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49149   Dali::TouchData *arg2 = 0 ;
49150
49151   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49152   arg2 = (Dali::TouchData *)jarg2;
49153   if (!arg2) {
49154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
49155     return ;
49156   }
49157   {
49158     try {
49159       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
49160     } catch (std::out_of_range& e) {
49161       {
49162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49163       };
49164     } catch (std::exception& e) {
49165       {
49166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49167       };
49168     } catch (...) {
49169       {
49170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49171       };
49172     }
49173   }
49174 }
49175
49176
49177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
49178   void * jresult ;
49179   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
49180
49181   {
49182     try {
49183       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
49184     } catch (std::out_of_range& e) {
49185       {
49186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49187       };
49188     } catch (std::exception& e) {
49189       {
49190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49191       };
49192     } catch (...) {
49193       {
49194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49195       };
49196     }
49197   }
49198   jresult = (void *)result;
49199   return jresult;
49200 }
49201
49202
49203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
49204   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49205
49206   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49207   {
49208     try {
49209       delete arg1;
49210     } catch (std::out_of_range& e) {
49211       {
49212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49213       };
49214     } catch (std::exception& e) {
49215       {
49216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49217       };
49218     } catch (...) {
49219       {
49220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49221       };
49222     }
49223   }
49224 }
49225
49226
49227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
49228   unsigned int jresult ;
49229   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49230   bool result;
49231
49232   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49233   {
49234     try {
49235       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49236     } catch (std::out_of_range& e) {
49237       {
49238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49239       };
49240     } catch (std::exception& e) {
49241       {
49242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49243       };
49244     } catch (...) {
49245       {
49246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49247       };
49248     }
49249   }
49250   jresult = result;
49251   return jresult;
49252 }
49253
49254
49255 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
49256   unsigned long jresult ;
49257   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49258   std::size_t result;
49259
49260   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49261   {
49262     try {
49263       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49264     } catch (std::out_of_range& e) {
49265       {
49266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49267       };
49268     } catch (std::exception& e) {
49269       {
49270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49271       };
49272     } catch (...) {
49273       {
49274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49275       };
49276     }
49277   }
49278   jresult = (unsigned long)result;
49279   return jresult;
49280 }
49281
49282
49283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
49284   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49285   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49286
49287   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49288   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49289   {
49290     try {
49291       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49292     } catch (std::out_of_range& e) {
49293       {
49294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49295       };
49296     } catch (std::exception& e) {
49297       {
49298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49299       };
49300     } catch (...) {
49301       {
49302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49303       };
49304     }
49305   }
49306 }
49307
49308
49309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
49310   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49311   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49312
49313   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49314   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49315   {
49316     try {
49317       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49318     } catch (std::out_of_range& e) {
49319       {
49320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49321       };
49322     } catch (std::exception& e) {
49323       {
49324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49325       };
49326     } catch (...) {
49327       {
49328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49329       };
49330     }
49331   }
49332 }
49333
49334
49335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
49336   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49337   Dali::WheelEvent *arg2 = 0 ;
49338
49339   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49340   arg2 = (Dali::WheelEvent *)jarg2;
49341   if (!arg2) {
49342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
49343     return ;
49344   }
49345   {
49346     try {
49347       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
49348     } catch (std::out_of_range& e) {
49349       {
49350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49351       };
49352     } catch (std::exception& e) {
49353       {
49354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49355       };
49356     } catch (...) {
49357       {
49358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49359       };
49360     }
49361   }
49362 }
49363
49364
49365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
49366   void * jresult ;
49367   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
49368
49369   {
49370     try {
49371       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
49372     } catch (std::out_of_range& e) {
49373       {
49374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49375       };
49376     } catch (std::exception& e) {
49377       {
49378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49379       };
49380     } catch (...) {
49381       {
49382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49383       };
49384     }
49385   }
49386   jresult = (void *)result;
49387   return jresult;
49388 }
49389
49390
49391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
49392   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49393
49394   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49395   {
49396     try {
49397       delete arg1;
49398     } catch (std::out_of_range& e) {
49399       {
49400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49401       };
49402     } catch (std::exception& e) {
49403       {
49404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49405       };
49406     } catch (...) {
49407       {
49408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49409       };
49410     }
49411   }
49412 }
49413
49414
49415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
49416   void * jresult ;
49417   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49418
49419   {
49420     try {
49421       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
49422     } catch (std::out_of_range& e) {
49423       {
49424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49425       };
49426     } catch (std::exception& e) {
49427       {
49428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49429       };
49430     } catch (...) {
49431       {
49432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49433       };
49434     }
49435   }
49436   jresult = (void *)result;
49437   return jresult;
49438 }
49439
49440
49441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
49442   void * jresult ;
49443   Dali::Radian arg1 ;
49444   Dali::Radian arg2 ;
49445   Dali::Radian *argp1 ;
49446   Dali::Radian *argp2 ;
49447   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49448
49449   argp1 = (Dali::Radian *)jarg1;
49450   if (!argp1) {
49451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49452     return 0;
49453   }
49454   arg1 = *argp1;
49455   argp2 = (Dali::Radian *)jarg2;
49456   if (!argp2) {
49457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49458     return 0;
49459   }
49460   arg2 = *argp2;
49461   {
49462     try {
49463       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
49464     } catch (std::out_of_range& e) {
49465       {
49466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49467       };
49468     } catch (std::exception& e) {
49469       {
49470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49471       };
49472     } catch (...) {
49473       {
49474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49475       };
49476     }
49477   }
49478   jresult = (void *)result;
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
49484   void * jresult ;
49485   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
49486   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49487
49488   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49489   if (!arg1) {
49490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
49491     return 0;
49492   }
49493   {
49494     try {
49495       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
49496     } catch (std::out_of_range& e) {
49497       {
49498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49499       };
49500     } catch (std::exception& e) {
49501       {
49502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49503       };
49504     } catch (...) {
49505       {
49506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49507       };
49508     }
49509   }
49510   jresult = (void *)result;
49511   return jresult;
49512 }
49513
49514
49515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
49516   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49517   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49518
49519   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49520   arg2 = (Dali::Radian *)jarg2;
49521   if (arg1) (arg1)->first = *arg2;
49522 }
49523
49524
49525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
49526   void * jresult ;
49527   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49528   Dali::Radian *result = 0 ;
49529
49530   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49531   result = (Dali::Radian *)& ((arg1)->first);
49532   jresult = (void *)result;
49533   return jresult;
49534 }
49535
49536
49537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
49538   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49539   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49540
49541   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49542   arg2 = (Dali::Radian *)jarg2;
49543   if (arg1) (arg1)->second = *arg2;
49544 }
49545
49546
49547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
49548   void * jresult ;
49549   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49550   Dali::Radian *result = 0 ;
49551
49552   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49553   result = (Dali::Radian *)& ((arg1)->second);
49554   jresult = (void *)result;
49555   return jresult;
49556 }
49557
49558
49559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
49560   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49561
49562   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49563   {
49564     try {
49565       delete arg1;
49566     } catch (std::out_of_range& e) {
49567       {
49568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49569       };
49570     } catch (std::exception& e) {
49571       {
49572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49573       };
49574     } catch (...) {
49575       {
49576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49577       };
49578     }
49579   }
49580 }
49581
49582
49583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
49584   unsigned int jresult ;
49585   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49586   bool result;
49587
49588   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49589   {
49590     try {
49591       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);
49592     } catch (std::out_of_range& e) {
49593       {
49594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49595       };
49596     } catch (std::exception& e) {
49597       {
49598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49599       };
49600     } catch (...) {
49601       {
49602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49603       };
49604     }
49605   }
49606   jresult = result;
49607   return jresult;
49608 }
49609
49610
49611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49612   unsigned long jresult ;
49613   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49614   std::size_t result;
49615
49616   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49617   {
49618     try {
49619       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);
49620     } catch (std::out_of_range& e) {
49621       {
49622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49623       };
49624     } catch (std::exception& e) {
49625       {
49626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49627       };
49628     } catch (...) {
49629       {
49630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49631       };
49632     }
49633   }
49634   jresult = (unsigned long)result;
49635   return jresult;
49636 }
49637
49638
49639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49640   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49641   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49642
49643   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49644   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49645   {
49646     try {
49647       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49648     } catch (std::out_of_range& e) {
49649       {
49650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49651       };
49652     } catch (std::exception& e) {
49653       {
49654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49655       };
49656     } catch (...) {
49657       {
49658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49659       };
49660     }
49661   }
49662 }
49663
49664
49665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49666   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49667   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49668
49669   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49670   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49671   {
49672     try {
49673       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49674     } catch (std::out_of_range& e) {
49675       {
49676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (std::exception& e) {
49679       {
49680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688 }
49689
49690
49691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49692   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49693   Dali::Actor arg2 ;
49694   Dali::PanGesture *arg3 = 0 ;
49695   Dali::Actor *argp2 ;
49696
49697   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49698   argp2 = (Dali::Actor *)jarg2;
49699   if (!argp2) {
49700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49701     return ;
49702   }
49703   arg2 = *argp2;
49704   arg3 = (Dali::PanGesture *)jarg3;
49705   if (!arg3) {
49706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
49707     return ;
49708   }
49709   {
49710     try {
49711       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
49712     } catch (std::out_of_range& e) {
49713       {
49714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49715       };
49716     } catch (std::exception& e) {
49717       {
49718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49719       };
49720     } catch (...) {
49721       {
49722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49723       };
49724     }
49725   }
49726 }
49727
49728
49729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
49730   void * jresult ;
49731   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
49732
49733   {
49734     try {
49735       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
49736     } catch (std::out_of_range& e) {
49737       {
49738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49739       };
49740     } catch (std::exception& e) {
49741       {
49742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49743       };
49744     } catch (...) {
49745       {
49746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49747       };
49748     }
49749   }
49750   jresult = (void *)result;
49751   return jresult;
49752 }
49753
49754
49755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
49756   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49757
49758   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49759   {
49760     try {
49761       delete arg1;
49762     } catch (std::out_of_range& e) {
49763       {
49764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49765       };
49766     } catch (std::exception& e) {
49767       {
49768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49769       };
49770     } catch (...) {
49771       {
49772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49773       };
49774     }
49775   }
49776 }
49777
49778
49779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
49780   unsigned int jresult ;
49781   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49782   bool result;
49783
49784   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49785   {
49786     try {
49787       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);
49788     } catch (std::out_of_range& e) {
49789       {
49790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49791       };
49792     } catch (std::exception& e) {
49793       {
49794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49795       };
49796     } catch (...) {
49797       {
49798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49799       };
49800     }
49801   }
49802   jresult = result;
49803   return jresult;
49804 }
49805
49806
49807 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49808   unsigned long jresult ;
49809   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49810   std::size_t result;
49811
49812   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49813   {
49814     try {
49815       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);
49816     } catch (std::out_of_range& e) {
49817       {
49818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49819       };
49820     } catch (std::exception& e) {
49821       {
49822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49823       };
49824     } catch (...) {
49825       {
49826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49827       };
49828     }
49829   }
49830   jresult = (unsigned long)result;
49831   return jresult;
49832 }
49833
49834
49835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49836   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49837   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49838
49839   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49840   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49841   {
49842     try {
49843       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49844     } catch (std::out_of_range& e) {
49845       {
49846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49847       };
49848     } catch (std::exception& e) {
49849       {
49850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49851       };
49852     } catch (...) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49855       };
49856     }
49857   }
49858 }
49859
49860
49861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49862   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49863   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49864
49865   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49866   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49867   {
49868     try {
49869       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49870     } catch (std::out_of_range& e) {
49871       {
49872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49873       };
49874     } catch (std::exception& e) {
49875       {
49876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49877       };
49878     } catch (...) {
49879       {
49880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49881       };
49882     }
49883   }
49884 }
49885
49886
49887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49888   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49889   Dali::Actor arg2 ;
49890   Dali::PinchGesture *arg3 = 0 ;
49891   Dali::Actor *argp2 ;
49892
49893   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49894   argp2 = (Dali::Actor *)jarg2;
49895   if (!argp2) {
49896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49897     return ;
49898   }
49899   arg2 = *argp2;
49900   arg3 = (Dali::PinchGesture *)jarg3;
49901   if (!arg3) {
49902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
49903     return ;
49904   }
49905   {
49906     try {
49907       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
49908     } catch (std::out_of_range& e) {
49909       {
49910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49911       };
49912     } catch (std::exception& e) {
49913       {
49914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49915       };
49916     } catch (...) {
49917       {
49918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49919       };
49920     }
49921   }
49922 }
49923
49924
49925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
49926   void * jresult ;
49927   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
49928
49929   {
49930     try {
49931       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
49932     } catch (std::out_of_range& e) {
49933       {
49934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49935       };
49936     } catch (std::exception& e) {
49937       {
49938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49939       };
49940     } catch (...) {
49941       {
49942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49943       };
49944     }
49945   }
49946   jresult = (void *)result;
49947   return jresult;
49948 }
49949
49950
49951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
49952   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49953
49954   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49955   {
49956     try {
49957       delete arg1;
49958     } catch (std::out_of_range& e) {
49959       {
49960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49961       };
49962     } catch (std::exception& e) {
49963       {
49964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49965       };
49966     } catch (...) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49969       };
49970     }
49971   }
49972 }
49973
49974
49975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
49976   unsigned int jresult ;
49977   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
49978   bool result;
49979
49980   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
49981   {
49982     try {
49983       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);
49984     } catch (std::out_of_range& e) {
49985       {
49986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49987       };
49988     } catch (std::exception& e) {
49989       {
49990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49991       };
49992     } catch (...) {
49993       {
49994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49995       };
49996     }
49997   }
49998   jresult = result;
49999   return jresult;
50000 }
50001
50002
50003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50004   unsigned long jresult ;
50005   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50006   std::size_t result;
50007
50008   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50009   {
50010     try {
50011       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);
50012     } catch (std::out_of_range& e) {
50013       {
50014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50015       };
50016     } catch (std::exception& e) {
50017       {
50018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50019       };
50020     } catch (...) {
50021       {
50022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50023       };
50024     }
50025   }
50026   jresult = (unsigned long)result;
50027   return jresult;
50028 }
50029
50030
50031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50032   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50033   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50034
50035   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50036   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50037   {
50038     try {
50039       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50040     } catch (std::out_of_range& e) {
50041       {
50042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50043       };
50044     } catch (std::exception& e) {
50045       {
50046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50047       };
50048     } catch (...) {
50049       {
50050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50051       };
50052     }
50053   }
50054 }
50055
50056
50057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50058   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50059   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50060
50061   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50062   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50063   {
50064     try {
50065       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50066     } catch (std::out_of_range& e) {
50067       {
50068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50069       };
50070     } catch (std::exception& e) {
50071       {
50072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50073       };
50074     } catch (...) {
50075       {
50076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50077       };
50078     }
50079   }
50080 }
50081
50082
50083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50084   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50085   Dali::Actor arg2 ;
50086   Dali::TapGesture *arg3 = 0 ;
50087   Dali::Actor *argp2 ;
50088
50089   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50090   argp2 = (Dali::Actor *)jarg2;
50091   if (!argp2) {
50092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50093     return ;
50094   }
50095   arg2 = *argp2;
50096   arg3 = (Dali::TapGesture *)jarg3;
50097   if (!arg3) {
50098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
50099     return ;
50100   }
50101   {
50102     try {
50103       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
50104     } catch (std::out_of_range& e) {
50105       {
50106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50107       };
50108     } catch (std::exception& e) {
50109       {
50110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50111       };
50112     } catch (...) {
50113       {
50114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50115       };
50116     }
50117   }
50118 }
50119
50120
50121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
50122   void * jresult ;
50123   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
50124
50125   {
50126     try {
50127       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
50128     } catch (std::out_of_range& e) {
50129       {
50130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50131       };
50132     } catch (std::exception& e) {
50133       {
50134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50135       };
50136     } catch (...) {
50137       {
50138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50139       };
50140     }
50141   }
50142   jresult = (void *)result;
50143   return jresult;
50144 }
50145
50146
50147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
50148   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50149
50150   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50151   {
50152     try {
50153       delete arg1;
50154     } catch (std::out_of_range& e) {
50155       {
50156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50157       };
50158     } catch (std::exception& e) {
50159       {
50160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50161       };
50162     } catch (...) {
50163       {
50164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50165       };
50166     }
50167   }
50168 }
50169
50170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
50171   unsigned int jresult ;
50172   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50173   bool result;
50174
50175   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50176   {
50177     try {
50178       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50179     } catch (std::out_of_range& e) {
50180       {
50181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50182       };
50183     } catch (std::exception& e) {
50184       {
50185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50186       };
50187     } catch (...) {
50188       {
50189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50190       };
50191     }
50192   }
50193   jresult = result;
50194   return jresult;
50195 }
50196
50197
50198 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
50199   unsigned long jresult ;
50200   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50201   std::size_t result;
50202
50203   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50204   {
50205     try {
50206       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50207     } catch (std::out_of_range& e) {
50208       {
50209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50210       };
50211     } catch (std::exception& e) {
50212       {
50213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50214       };
50215     } catch (...) {
50216       {
50217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50218       };
50219     }
50220   }
50221   jresult = (unsigned long)result;
50222   return jresult;
50223 }
50224
50225
50226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
50227   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50228   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50229
50230   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50231   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50232   {
50233     try {
50234       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
50235     } catch (std::out_of_range& e) {
50236       {
50237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50238       };
50239     } catch (std::exception& e) {
50240       {
50241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50242       };
50243     } catch (...) {
50244       {
50245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50246       };
50247     }
50248   }
50249 }
50250
50251
50252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
50253   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50254   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50255
50256   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50257   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50258   {
50259     try {
50260       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
50261     } catch (std::out_of_range& e) {
50262       {
50263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50264       };
50265     } catch (std::exception& e) {
50266       {
50267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50268       };
50269     } catch (...) {
50270       {
50271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50272       };
50273     }
50274   }
50275 }
50276
50277
50278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
50279   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50280   Dali::ResourceImage arg2 ;
50281   Dali::ResourceImage *argp2 ;
50282
50283   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50284   argp2 = (Dali::ResourceImage *)jarg2;
50285   if (!argp2) {
50286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
50287     return ;
50288   }
50289   arg2 = *argp2;
50290   {
50291     try {
50292       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
50293     } catch (std::out_of_range& e) {
50294       {
50295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50296       };
50297     } catch (std::exception& e) {
50298       {
50299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50300       };
50301     } catch (...) {
50302       {
50303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50304       };
50305     }
50306   }
50307 }
50308
50309
50310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
50311   void * jresult ;
50312   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
50313
50314   {
50315     try {
50316       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
50317     } catch (std::out_of_range& e) {
50318       {
50319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50320       };
50321     } catch (std::exception& e) {
50322       {
50323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50324       };
50325     } catch (...) {
50326       {
50327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50328       };
50329     }
50330   }
50331   jresult = (void *)result;
50332   return jresult;
50333 }
50334
50335
50336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
50337   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50338
50339   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50340   {
50341     try {
50342       delete arg1;
50343     } catch (std::out_of_range& e) {
50344       {
50345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50346       };
50347     } catch (std::exception& e) {
50348       {
50349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50350       };
50351     } catch (...) {
50352       {
50353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50354       };
50355     }
50356   }
50357 }
50358
50359
50360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
50361   unsigned int jresult ;
50362   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50363   bool result;
50364
50365   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50366   {
50367     try {
50368       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);
50369     } catch (std::out_of_range& e) {
50370       {
50371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50372       };
50373     } catch (std::exception& e) {
50374       {
50375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50376       };
50377     } catch (...) {
50378       {
50379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50380       };
50381     }
50382   }
50383   jresult = result;
50384   return jresult;
50385 }
50386
50387
50388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
50389   unsigned long jresult ;
50390   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50391   std::size_t result;
50392
50393   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50394   {
50395     try {
50396       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);
50397     } catch (std::out_of_range& e) {
50398       {
50399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50400       };
50401     } catch (std::exception& e) {
50402       {
50403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50404       };
50405     } catch (...) {
50406       {
50407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50408       };
50409     }
50410   }
50411   jresult = (unsigned long)result;
50412   return jresult;
50413 }
50414
50415
50416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
50417   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50418   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50419
50420   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50421   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50422   {
50423     try {
50424       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
50425     } catch (std::out_of_range& e) {
50426       {
50427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50428       };
50429     } catch (std::exception& e) {
50430       {
50431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50432       };
50433     } catch (...) {
50434       {
50435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50436       };
50437     }
50438   }
50439 }
50440
50441
50442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
50443   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50444   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50445
50446   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50447   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50448   {
50449     try {
50450       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
50451     } catch (std::out_of_range& e) {
50452       {
50453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50454       };
50455     } catch (std::exception& e) {
50456       {
50457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50458       };
50459     } catch (...) {
50460       {
50461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50462       };
50463     }
50464   }
50465 }
50466
50467
50468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
50469   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50470   Dali::Actor arg2 ;
50471   bool arg3 ;
50472   Dali::DevelActor::VisibilityChange::Type arg4 ;
50473   Dali::Actor *argp2 ;
50474
50475   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50476   argp2 = (Dali::Actor *)jarg2;
50477   if (!argp2) {
50478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50479     return ;
50480   }
50481   arg2 = *argp2;
50482   arg3 = jarg3 ? true : false;
50483   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
50484   {
50485     try {
50486       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
50487     } catch (std::out_of_range& e) {
50488       {
50489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50490       };
50491     } catch (std::exception& e) {
50492       {
50493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50494       };
50495     } catch (...) {
50496       {
50497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50498       };
50499     }
50500   }
50501 }
50502
50503
50504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
50505   void * jresult ;
50506   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
50507
50508   {
50509     try {
50510       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
50511     } catch (std::out_of_range& e) {
50512       {
50513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50514       };
50515     } catch (std::exception& e) {
50516       {
50517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50518       };
50519     } catch (...) {
50520       {
50521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50522       };
50523     }
50524   }
50525   jresult = (void *)result;
50526   return jresult;
50527 }
50528
50529
50530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
50531   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50532
50533   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50534   {
50535     try {
50536       delete arg1;
50537     } catch (std::out_of_range& e) {
50538       {
50539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50540       };
50541     } catch (std::exception& e) {
50542       {
50543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50544       };
50545     } catch (...) {
50546       {
50547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50548       };
50549     }
50550   }
50551 }
50552
50553
50554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
50555   void * jresult ;
50556   Dali::Timer *result = 0 ;
50557
50558   {
50559     try {
50560       result = (Dali::Timer *)new Dali::Timer();
50561     } catch (std::out_of_range& e) {
50562       {
50563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50564       };
50565     } catch (std::exception& e) {
50566       {
50567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50568       };
50569     } catch (...) {
50570       {
50571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50572       };
50573     }
50574   }
50575   jresult = (void *)result;
50576   return jresult;
50577 }
50578
50579
50580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
50581   void * jresult ;
50582   unsigned int arg1 ;
50583   Dali::Timer result;
50584
50585   arg1 = (unsigned int)jarg1;
50586   {
50587     try {
50588       result = Dali::Timer::New(arg1);
50589     } catch (std::out_of_range& e) {
50590       {
50591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50592       };
50593     } catch (std::exception& e) {
50594       {
50595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50596       };
50597     } catch (...) {
50598       {
50599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50600       };
50601     }
50602   }
50603   jresult = new Dali::Timer((const Dali::Timer &)result);
50604   return jresult;
50605 }
50606
50607
50608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
50609   void * jresult ;
50610   Dali::Timer *arg1 = 0 ;
50611   Dali::Timer *result = 0 ;
50612
50613   arg1 = (Dali::Timer *)jarg1;
50614   if (!arg1) {
50615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50616     return 0;
50617   }
50618   {
50619     try {
50620       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
50621     } catch (std::out_of_range& e) {
50622       {
50623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50624       };
50625     } catch (std::exception& e) {
50626       {
50627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50628       };
50629     } catch (...) {
50630       {
50631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50632       };
50633     }
50634   }
50635   jresult = (void *)result;
50636   return jresult;
50637 }
50638
50639
50640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
50641   void * jresult ;
50642   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50643   Dali::Timer *arg2 = 0 ;
50644   Dali::Timer *result = 0 ;
50645
50646   arg1 = (Dali::Timer *)jarg1;
50647   arg2 = (Dali::Timer *)jarg2;
50648   if (!arg2) {
50649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50650     return 0;
50651   }
50652   {
50653     try {
50654       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
50655     } catch (std::out_of_range& e) {
50656       {
50657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50658       };
50659     } catch (std::exception& e) {
50660       {
50661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50662       };
50663     } catch (...) {
50664       {
50665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50666       };
50667     }
50668   }
50669   jresult = (void *)result;
50670   return jresult;
50671 }
50672
50673
50674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
50675   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50676
50677   arg1 = (Dali::Timer *)jarg1;
50678   {
50679     try {
50680       delete arg1;
50681     } catch (std::out_of_range& e) {
50682       {
50683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50684       };
50685     } catch (std::exception& e) {
50686       {
50687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50688       };
50689     } catch (...) {
50690       {
50691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50692       };
50693     }
50694   }
50695 }
50696
50697
50698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
50699   void * jresult ;
50700   Dali::BaseHandle arg1 ;
50701   Dali::BaseHandle *argp1 ;
50702   Dali::Timer result;
50703
50704   argp1 = (Dali::BaseHandle *)jarg1;
50705   if (!argp1) {
50706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50707     return 0;
50708   }
50709   arg1 = *argp1;
50710   {
50711     try {
50712       result = Dali::Timer::DownCast(arg1);
50713     } catch (std::out_of_range& e) {
50714       {
50715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50716       };
50717     } catch (std::exception& e) {
50718       {
50719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50720       };
50721     } catch (...) {
50722       {
50723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50724       };
50725     }
50726   }
50727   jresult = new Dali::Timer((const Dali::Timer &)result);
50728   return jresult;
50729 }
50730
50731
50732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
50733   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50734
50735   arg1 = (Dali::Timer *)jarg1;
50736   {
50737     try {
50738       (arg1)->Start();
50739     } catch (std::out_of_range& e) {
50740       {
50741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50742       };
50743     } catch (std::exception& e) {
50744       {
50745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50746       };
50747     } catch (...) {
50748       {
50749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50750       };
50751     }
50752   }
50753 }
50754
50755
50756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
50757   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50758
50759   arg1 = (Dali::Timer *)jarg1;
50760   {
50761     try {
50762       (arg1)->Stop();
50763     } catch (std::out_of_range& e) {
50764       {
50765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50766       };
50767     } catch (std::exception& e) {
50768       {
50769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50770       };
50771     } catch (...) {
50772       {
50773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50774       };
50775     }
50776   }
50777 }
50778
50779
50780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
50781   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50782   unsigned int arg2 ;
50783
50784   arg1 = (Dali::Timer *)jarg1;
50785   arg2 = (unsigned int)jarg2;
50786   {
50787     try {
50788       (arg1)->SetInterval(arg2);
50789     } catch (std::out_of_range& e) {
50790       {
50791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50792       };
50793     } catch (std::exception& e) {
50794       {
50795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50796       };
50797     } catch (...) {
50798       {
50799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50800       };
50801     }
50802   }
50803 }
50804
50805
50806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
50807   unsigned int jresult ;
50808   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50809   unsigned int result;
50810
50811   arg1 = (Dali::Timer *)jarg1;
50812   {
50813     try {
50814       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
50815     } catch (std::out_of_range& e) {
50816       {
50817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50818       };
50819     } catch (std::exception& e) {
50820       {
50821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50822       };
50823     } catch (...) {
50824       {
50825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50826       };
50827     }
50828   }
50829   jresult = result;
50830   return jresult;
50831 }
50832
50833
50834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
50835   unsigned int jresult ;
50836   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50837   bool result;
50838
50839   arg1 = (Dali::Timer *)jarg1;
50840   {
50841     try {
50842       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
50843     } catch (std::out_of_range& e) {
50844       {
50845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50846       };
50847     } catch (std::exception& e) {
50848       {
50849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50850       };
50851     } catch (...) {
50852       {
50853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50854       };
50855     }
50856   }
50857   jresult = result;
50858   return jresult;
50859 }
50860
50861
50862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
50863   void * jresult ;
50864   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50865   Dali::Timer::TimerSignalType *result = 0 ;
50866
50867   arg1 = (Dali::Timer *)jarg1;
50868   {
50869     try {
50870       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
50871     } catch (std::out_of_range& e) {
50872       {
50873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50874       };
50875     } catch (std::exception& e) {
50876       {
50877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50878       };
50879     } catch (...) {
50880       {
50881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50882       };
50883     }
50884   }
50885   jresult = (void *)result;
50886   return jresult;
50887 }
50888
50889
50890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
50891   void * jresult ;
50892   Dali::DragAndDropDetector *result = 0 ;
50893
50894   {
50895     try {
50896       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
50897     } catch (std::out_of_range& e) {
50898       {
50899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50900       };
50901     } catch (std::exception& e) {
50902       {
50903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50904       };
50905     } catch (...) {
50906       {
50907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50908       };
50909     }
50910   }
50911   jresult = (void *)result;
50912   return jresult;
50913 }
50914
50915
50916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
50917   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50918
50919   arg1 = (Dali::DragAndDropDetector *)jarg1;
50920   {
50921     try {
50922       delete arg1;
50923     } catch (std::out_of_range& e) {
50924       {
50925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50926       };
50927     } catch (std::exception& e) {
50928       {
50929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50930       };
50931     } catch (...) {
50932       {
50933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50934       };
50935     }
50936   }
50937 }
50938
50939
50940 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
50941   char * jresult ;
50942   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50943   std::string *result = 0 ;
50944
50945   arg1 = (Dali::DragAndDropDetector *)jarg1;
50946   {
50947     try {
50948       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
50949     } catch (std::out_of_range& e) {
50950       {
50951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50952       };
50953     } catch (std::exception& e) {
50954       {
50955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50956       };
50957     } catch (...) {
50958       {
50959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50960       };
50961     }
50962   }
50963   jresult = SWIG_csharp_string_callback(result->c_str());
50964   return jresult;
50965 }
50966
50967
50968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
50969   void * jresult ;
50970   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50971   Dali::Vector2 result;
50972
50973   arg1 = (Dali::DragAndDropDetector *)jarg1;
50974   {
50975     try {
50976       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
50977     } catch (std::out_of_range& e) {
50978       {
50979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50980       };
50981     } catch (std::exception& e) {
50982       {
50983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50984       };
50985     } catch (...) {
50986       {
50987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50988       };
50989     }
50990   }
50991   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
50992   return jresult;
50993 }
50994
50995
50996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
50997   void * jresult ;
50998   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50999   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51000
51001   arg1 = (Dali::DragAndDropDetector *)jarg1;
51002   {
51003     try {
51004       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
51005     } catch (std::out_of_range& e) {
51006       {
51007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51008       };
51009     } catch (std::exception& e) {
51010       {
51011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51012       };
51013     } catch (...) {
51014       {
51015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51016       };
51017     }
51018   }
51019   jresult = (void *)result;
51020   return jresult;
51021 }
51022
51023
51024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
51025   void * jresult ;
51026   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51027   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51028
51029   arg1 = (Dali::DragAndDropDetector *)jarg1;
51030   {
51031     try {
51032       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
51033     } catch (std::out_of_range& e) {
51034       {
51035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51036       };
51037     } catch (std::exception& e) {
51038       {
51039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51044       };
51045     }
51046   }
51047   jresult = (void *)result;
51048   return jresult;
51049 }
51050
51051
51052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
51053   void * jresult ;
51054   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51055   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51056
51057   arg1 = (Dali::DragAndDropDetector *)jarg1;
51058   {
51059     try {
51060       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
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_DragAndDropDetector_DroppedSignal(void * jarg1) {
51081   void * jresult ;
51082   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51083   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51084
51085   arg1 = (Dali::DragAndDropDetector *)jarg1;
51086   {
51087     try {
51088       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
51089     } catch (std::out_of_range& e) {
51090       {
51091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51092       };
51093     } catch (std::exception& e) {
51094       {
51095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51096       };
51097     } catch (...) {
51098       {
51099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51100       };
51101     }
51102   }
51103   jresult = (void *)result;
51104   return jresult;
51105 }
51106
51107
51108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
51109   void * jresult ;
51110   Dali::ApplicationExtensions *result = 0 ;
51111
51112   {
51113     try {
51114       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
51115     } catch (std::out_of_range& e) {
51116       {
51117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51118       };
51119     } catch (std::exception& e) {
51120       {
51121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51122       };
51123     } catch (...) {
51124       {
51125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51126       };
51127     }
51128   }
51129   jresult = (void *)result;
51130   return jresult;
51131 }
51132
51133
51134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
51135   void * jresult ;
51136   Dali::Application *arg1 = (Dali::Application *) 0 ;
51137   Dali::ApplicationExtensions *result = 0 ;
51138
51139   arg1 = (Dali::Application *)jarg1;
51140   {
51141     try {
51142       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
51143     } catch (std::out_of_range& e) {
51144       {
51145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51146       };
51147     } catch (std::exception& e) {
51148       {
51149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51150       };
51151     } catch (...) {
51152       {
51153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51154       };
51155     }
51156   }
51157   jresult = (void *)result;
51158   return jresult;
51159 }
51160
51161
51162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
51163   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51164
51165   arg1 = (Dali::ApplicationExtensions *)jarg1;
51166   {
51167     try {
51168       delete arg1;
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_ApplicationExtensions_Init(void * jarg1) {
51187   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51188
51189   arg1 = (Dali::ApplicationExtensions *)jarg1;
51190   {
51191     try {
51192       (arg1)->Init();
51193     } catch (std::out_of_range& e) {
51194       {
51195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51196       };
51197     } catch (std::exception& e) {
51198       {
51199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51200       };
51201     } catch (...) {
51202       {
51203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51204       };
51205     }
51206   }
51207 }
51208
51209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
51210   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51211
51212   arg1 = (Dali::ApplicationExtensions *)jarg1;
51213   {
51214     try {
51215       (arg1)->Start();
51216     } catch (std::out_of_range& e) {
51217       {
51218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51219       };
51220     } catch (std::exception& e) {
51221       {
51222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51223       };
51224     } catch (...) {
51225       {
51226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51227       };
51228     }
51229   }
51230 }
51231
51232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
51233   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51234
51235   arg1 = (Dali::ApplicationExtensions *)jarg1;
51236   {
51237     try {
51238       (arg1)->Terminate();
51239     } catch (std::out_of_range& e) {
51240       {
51241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51242       };
51243     } catch (std::exception& e) {
51244       {
51245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51246       };
51247     } catch (...) {
51248       {
51249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51250       };
51251     }
51252   }
51253 }
51254
51255
51256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
51257   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51258
51259   arg1 = (Dali::ApplicationExtensions *)jarg1;
51260   {
51261     try {
51262       (arg1)->Pause();
51263     } catch (std::out_of_range& e) {
51264       {
51265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51266       };
51267     } catch (std::exception& e) {
51268       {
51269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51270       };
51271     } catch (...) {
51272       {
51273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51274       };
51275     }
51276   }
51277 }
51278
51279
51280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
51281   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51282
51283   arg1 = (Dali::ApplicationExtensions *)jarg1;
51284   {
51285     try {
51286       (arg1)->Resume();
51287     } catch (std::out_of_range& e) {
51288       {
51289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51290       };
51291     } catch (std::exception& e) {
51292       {
51293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51294       };
51295     } catch (...) {
51296       {
51297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51298       };
51299     }
51300   }
51301 }
51302
51303
51304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
51305   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51306
51307   arg1 = (Dali::ApplicationExtensions *)jarg1;
51308   {
51309     try {
51310       (arg1)->LanguageChange();
51311     } catch (std::out_of_range& e) {
51312       {
51313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51314       };
51315     } catch (std::exception& e) {
51316       {
51317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51318       };
51319     } catch (...) {
51320       {
51321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51322       };
51323     }
51324   }
51325 }
51326
51327
51328
51329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
51330   unsigned int jresult ;
51331   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51332   bool result;
51333
51334   arg1 = (Dali::Signal< bool () > *)jarg1;
51335   {
51336     try {
51337       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
51338     } catch (std::out_of_range& e) {
51339       {
51340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51341       };
51342     } catch (std::exception& e) {
51343       {
51344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51345       };
51346     } catch (...) {
51347       {
51348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51349       };
51350     }
51351   }
51352   jresult = result;
51353   return jresult;
51354 }
51355
51356
51357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
51358   unsigned long jresult ;
51359   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51360   std::size_t result;
51361
51362   arg1 = (Dali::Signal< bool () > *)jarg1;
51363   {
51364     try {
51365       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
51366     } catch (std::out_of_range& e) {
51367       {
51368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51369       };
51370     } catch (std::exception& e) {
51371       {
51372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51373       };
51374     } catch (...) {
51375       {
51376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51377       };
51378     }
51379   }
51380   jresult = (unsigned long)result;
51381   return jresult;
51382 }
51383
51384
51385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
51386   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51387   bool (*arg2)() = (bool (*)()) 0 ;
51388
51389   arg1 = (Dali::Signal< bool () > *)jarg1;
51390   arg2 = (bool (*)())jarg2;
51391   {
51392     try {
51393       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
51394     } catch (std::out_of_range& e) {
51395       {
51396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51397       };
51398     } catch (std::exception& e) {
51399       {
51400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51401       };
51402     } catch (...) {
51403       {
51404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51405       };
51406     }
51407   }
51408 }
51409
51410
51411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
51412   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51413   bool (*arg2)() = (bool (*)()) 0 ;
51414
51415   arg1 = (Dali::Signal< bool () > *)jarg1;
51416   arg2 = (bool (*)())jarg2;
51417   {
51418     try {
51419       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
51420     } catch (std::out_of_range& e) {
51421       {
51422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51423       };
51424     } catch (std::exception& e) {
51425       {
51426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51427       };
51428     } catch (...) {
51429       {
51430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51431       };
51432     }
51433   }
51434 }
51435
51436
51437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
51438   unsigned int jresult ;
51439   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51440   bool result;
51441
51442   arg1 = (Dali::Signal< bool () > *)jarg1;
51443   {
51444     try {
51445       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
51446     } catch (std::out_of_range& e) {
51447       {
51448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51449       };
51450     } catch (std::exception& e) {
51451       {
51452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51453       };
51454     } catch (...) {
51455       {
51456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51457       };
51458     }
51459   }
51460   jresult = result;
51461   return jresult;
51462 }
51463
51464
51465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
51466   void * jresult ;
51467   Dali::Signal< bool () > *result = 0 ;
51468
51469   {
51470     try {
51471       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
51472     } catch (std::out_of_range& e) {
51473       {
51474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51475       };
51476     } catch (std::exception& e) {
51477       {
51478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51479       };
51480     } catch (...) {
51481       {
51482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51483       };
51484     }
51485   }
51486   jresult = (void *)result;
51487   return jresult;
51488 }
51489
51490
51491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
51492   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51493
51494   arg1 = (Dali::Signal< bool () > *)jarg1;
51495   {
51496     try {
51497       delete arg1;
51498     } catch (std::out_of_range& e) {
51499       {
51500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51501       };
51502     } catch (std::exception& e) {
51503       {
51504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51505       };
51506     } catch (...) {
51507       {
51508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51509       };
51510     }
51511   }
51512 }
51513
51514
51515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
51516   int jresult ;
51517   int result;
51518
51519   {
51520     try {
51521       result = (int)Dali::Toolkit::Visual::Property::TYPE;
51522     } catch (std::out_of_range& e) {
51523       {
51524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51525       };
51526     } catch (std::exception& e) {
51527       {
51528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51529       };
51530     } catch (...) {
51531       {
51532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51533       };
51534     }
51535   }
51536   jresult = (int)result;
51537   return jresult;
51538 }
51539
51540
51541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
51542   int jresult ;
51543   int result;
51544
51545   {
51546     try {
51547       result = (int)Dali::Toolkit::Visual::Property::SHADER;
51548     } catch (std::out_of_range& e) {
51549       {
51550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51551       };
51552     } catch (std::exception& e) {
51553       {
51554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51555       };
51556     } catch (...) {
51557       {
51558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51559       };
51560     }
51561   }
51562   jresult = (int)result;
51563   return jresult;
51564 }
51565
51566
51567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
51568   int jresult ;
51569   int result;
51570
51571   {
51572     try {
51573       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
51574     } catch (std::out_of_range& e) {
51575       {
51576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51577       };
51578     } catch (std::exception& e) {
51579       {
51580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51581       };
51582     } catch (...) {
51583       {
51584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51585       };
51586     }
51587   }
51588   jresult = (int)result;
51589   return jresult;
51590 }
51591
51592
51593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
51594   int jresult ;
51595   int result;
51596
51597   {
51598     try {
51599       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
51600     } catch (std::out_of_range& e) {
51601       {
51602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51603       };
51604     } catch (std::exception& e) {
51605       {
51606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51607       };
51608     } catch (...) {
51609       {
51610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51611       };
51612     }
51613   }
51614   jresult = (int)result;
51615   return jresult;
51616 }
51617
51618
51619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
51620   int jresult ;
51621   int result;
51622
51623   {
51624     try {
51625       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
51626     } catch (std::out_of_range& e) {
51627       {
51628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51629       };
51630     } catch (std::exception& e) {
51631       {
51632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51633       };
51634     } catch (...) {
51635       {
51636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51637       };
51638     }
51639   }
51640   jresult = (int)result;
51641   return jresult;
51642 }
51643
51644
51645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
51646   int jresult ;
51647   int result;
51648
51649   {
51650     try {
51651       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
51652     } catch (std::out_of_range& e) {
51653       {
51654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51655       };
51656     } catch (std::exception& e) {
51657       {
51658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51659       };
51660     } catch (...) {
51661       {
51662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51663       };
51664     }
51665   }
51666   jresult = (int)result;
51667   return jresult;
51668 }
51669
51670
51671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
51672   int jresult ;
51673   int result;
51674
51675   {
51676     try {
51677       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
51678     } catch (std::out_of_range& e) {
51679       {
51680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51681       };
51682     } catch (std::exception& e) {
51683       {
51684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51685       };
51686     } catch (...) {
51687       {
51688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51689       };
51690     }
51691   }
51692   jresult = (int)result;
51693   return jresult;
51694 }
51695
51696
51697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
51698   int jresult ;
51699   int result;
51700
51701   {
51702     try {
51703       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
51704     } catch (std::out_of_range& e) {
51705       {
51706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51707       };
51708     } catch (std::exception& e) {
51709       {
51710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51711       };
51712     } catch (...) {
51713       {
51714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51715       };
51716     }
51717   }
51718   jresult = (int)result;
51719   return jresult;
51720 }
51721
51722
51723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
51724   int jresult ;
51725   int result;
51726
51727   {
51728     try {
51729       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
51730     } catch (std::out_of_range& e) {
51731       {
51732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51733       };
51734     } catch (std::exception& e) {
51735       {
51736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51737       };
51738     } catch (...) {
51739       {
51740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51741       };
51742     }
51743   }
51744   jresult = (int)result;
51745   return jresult;
51746 }
51747
51748
51749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
51750   int jresult ;
51751   int result;
51752
51753   {
51754     try {
51755       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
51756     } catch (std::out_of_range& e) {
51757       {
51758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51759       };
51760     } catch (std::exception& e) {
51761       {
51762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51763       };
51764     } catch (...) {
51765       {
51766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51767       };
51768     }
51769   }
51770   jresult = (int)result;
51771   return jresult;
51772 }
51773
51774
51775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
51776   int jresult ;
51777   int result;
51778
51779   {
51780     try {
51781       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
51782     } catch (std::out_of_range& e) {
51783       {
51784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51785       };
51786     } catch (std::exception& e) {
51787       {
51788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51789       };
51790     } catch (...) {
51791       {
51792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51793       };
51794     }
51795   }
51796   jresult = (int)result;
51797   return jresult;
51798 }
51799
51800
51801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
51802   int jresult ;
51803   int result;
51804
51805   {
51806     try {
51807       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
51808     } catch (std::out_of_range& e) {
51809       {
51810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51811       };
51812     } catch (std::exception& e) {
51813       {
51814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51815       };
51816     } catch (...) {
51817       {
51818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51819       };
51820     }
51821   }
51822   jresult = (int)result;
51823   return jresult;
51824 }
51825
51826
51827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
51828   int jresult ;
51829   int result;
51830
51831   {
51832     try {
51833       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
51834     } catch (std::out_of_range& e) {
51835       {
51836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51837       };
51838     } catch (std::exception& e) {
51839       {
51840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51841       };
51842     } catch (...) {
51843       {
51844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51845       };
51846     }
51847   }
51848   jresult = (int)result;
51849   return jresult;
51850 }
51851
51852
51853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
51854   int jresult ;
51855   int result;
51856
51857   {
51858     try {
51859       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
51860     } catch (std::out_of_range& e) {
51861       {
51862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51863       };
51864     } catch (std::exception& e) {
51865       {
51866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51867       };
51868     } catch (...) {
51869       {
51870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51871       };
51872     }
51873   }
51874   jresult = (int)result;
51875   return jresult;
51876 }
51877
51878
51879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
51880   int jresult ;
51881   int result;
51882
51883   {
51884     try {
51885       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
51886     } catch (std::out_of_range& e) {
51887       {
51888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51889       };
51890     } catch (std::exception& e) {
51891       {
51892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51893       };
51894     } catch (...) {
51895       {
51896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51897       };
51898     }
51899   }
51900   jresult = (int)result;
51901   return jresult;
51902 }
51903
51904
51905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
51906   int jresult ;
51907   int result;
51908
51909   {
51910     try {
51911       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
51912     } catch (std::out_of_range& e) {
51913       {
51914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51915       };
51916     } catch (std::exception& e) {
51917       {
51918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51919       };
51920     } catch (...) {
51921       {
51922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51923       };
51924     }
51925   }
51926   jresult = (int)result;
51927   return jresult;
51928 }
51929
51930
51931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
51932   int jresult ;
51933   int result;
51934
51935   {
51936     try {
51937       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
51938     } catch (std::out_of_range& e) {
51939       {
51940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51941       };
51942     } catch (std::exception& e) {
51943       {
51944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51945       };
51946     } catch (...) {
51947       {
51948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51949       };
51950     }
51951   }
51952   jresult = (int)result;
51953   return jresult;
51954 }
51955
51956
51957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
51958   int jresult ;
51959   int result;
51960
51961   {
51962     try {
51963       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
51964     } catch (std::out_of_range& e) {
51965       {
51966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51967       };
51968     } catch (std::exception& e) {
51969       {
51970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51971       };
51972     } catch (...) {
51973       {
51974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51975       };
51976     }
51977   }
51978   jresult = (int)result;
51979   return jresult;
51980 }
51981
51982
51983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
51984   int jresult ;
51985   int result;
51986
51987   {
51988     try {
51989       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
51990     } catch (std::out_of_range& e) {
51991       {
51992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51993       };
51994     } catch (std::exception& e) {
51995       {
51996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51997       };
51998     } catch (...) {
51999       {
52000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52001       };
52002     }
52003   }
52004   jresult = (int)result;
52005   return jresult;
52006 }
52007
52008
52009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
52010   int jresult ;
52011   int result;
52012
52013   {
52014     try {
52015       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
52016     } catch (std::out_of_range& e) {
52017       {
52018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52019       };
52020     } catch (std::exception& e) {
52021       {
52022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52023       };
52024     } catch (...) {
52025       {
52026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52027       };
52028     }
52029   }
52030   jresult = (int)result;
52031   return jresult;
52032 }
52033
52034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
52035   int jresult ;
52036   int result;
52037
52038   {
52039     try {
52040       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
52041     } catch (std::out_of_range& e) {
52042       {
52043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52044       };
52045     } catch (std::exception& e) {
52046       {
52047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52048       };
52049     } catch (...) {
52050       {
52051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52052       };
52053     }
52054   }
52055   jresult = (int)result;
52056   return jresult;
52057 }
52058
52059
52060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
52061   int jresult ;
52062   int result;
52063   {
52064     try
52065     {
52066       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
52067     } catch (std::out_of_range& e) {
52068       {
52069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52070       };
52071     } catch (std::exception& e) {
52072       {
52073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52074       };
52075     } catch (...) {
52076       {
52077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52078       };
52079     }
52080   }
52081   jresult = (int)result;
52082   return jresult;
52083 }
52084
52085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
52086   int jresult ;
52087   int result;
52088   {
52089     try
52090     {
52091       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
52092     } catch (std::out_of_range& e) {
52093       {
52094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52095       };
52096     } catch (std::exception& e) {
52097       {
52098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52099       };
52100     } catch (...) {
52101       {
52102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52103       };
52104     }
52105   }
52106   jresult = (int)result;
52107   return jresult;
52108 }
52109
52110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
52111   int jresult ;
52112   int result;
52113   {
52114     try
52115     {
52116       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
52117     } catch (std::out_of_range& e) {
52118       {
52119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52120       };
52121     } catch (std::exception& e) {
52122       {
52123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52124       };
52125     } catch (...) {
52126       {
52127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52128       };
52129     }
52130   }
52131   jresult = (int)result;
52132   return jresult;
52133 }
52134
52135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
52136   int jresult ;
52137   int result;
52138   {
52139     try
52140     {
52141       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
52142     } catch (std::out_of_range& e) {
52143       {
52144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52145       };
52146     } catch (std::exception& e) {
52147       {
52148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52149       };
52150     } catch (...) {
52151       {
52152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52153       };
52154     }
52155   }
52156   jresult = (int)result;
52157   return jresult;
52158 }
52159
52160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
52161   int jresult ;
52162   int result;
52163   {
52164     try
52165     {
52166       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
52167     } catch (std::out_of_range& e) {
52168       {
52169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52170       };
52171     } catch (std::exception& e) {
52172       {
52173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52174       };
52175     } catch (...) {
52176       {
52177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52178       };
52179     }
52180   }
52181   jresult = (int)result;
52182   return jresult;
52183 }
52184
52185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
52186   int jresult ;
52187   int result;
52188
52189   {
52190     try {
52191       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
52192     } catch (std::out_of_range& e) {
52193       {
52194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52195       };
52196     } catch (std::exception& e) {
52197       {
52198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52199       };
52200     } catch (...) {
52201       {
52202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52203       };
52204     }
52205   }
52206   jresult = (int)result;
52207   return jresult;
52208 }
52209
52210
52211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
52212   int jresult ;
52213   int result;
52214
52215   {
52216     try {
52217       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
52218     } catch (std::out_of_range& e) {
52219       {
52220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52221       };
52222     } catch (std::exception& e) {
52223       {
52224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52225       };
52226     } catch (...) {
52227       {
52228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52229       };
52230     }
52231   }
52232   jresult = (int)result;
52233   return jresult;
52234 }
52235
52236
52237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
52238   int jresult ;
52239   int result;
52240
52241   {
52242     try {
52243       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
52244     } catch (std::out_of_range& e) {
52245       {
52246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52247       };
52248     } catch (std::exception& e) {
52249       {
52250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52251       };
52252     } catch (...) {
52253       {
52254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52255       };
52256     }
52257   }
52258   jresult = (int)result;
52259   return jresult;
52260 }
52261
52262
52263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
52264   int jresult ;
52265   int result;
52266
52267   {
52268     try {
52269       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
52270     } catch (std::out_of_range& e) {
52271       {
52272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52273       };
52274     } catch (std::exception& e) {
52275       {
52276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52277       };
52278     } catch (...) {
52279       {
52280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52281       };
52282     }
52283   }
52284   jresult = (int)result;
52285   return jresult;
52286 }
52287
52288
52289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
52290   int jresult ;
52291   int result;
52292
52293   {
52294     try {
52295       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
52296     } catch (std::out_of_range& e) {
52297       {
52298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52299       };
52300     } catch (std::exception& e) {
52301       {
52302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52303       };
52304     } catch (...) {
52305       {
52306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52307       };
52308     }
52309   }
52310   jresult = (int)result;
52311   return jresult;
52312 }
52313
52314
52315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
52316   int jresult ;
52317   int result;
52318
52319   {
52320     try {
52321       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
52322     } catch (std::out_of_range& e) {
52323       {
52324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52325       };
52326     } catch (std::exception& e) {
52327       {
52328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52329       };
52330     } catch (...) {
52331       {
52332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52333       };
52334     }
52335   }
52336   jresult = (int)result;
52337   return jresult;
52338 }
52339
52340
52341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
52342   int jresult ;
52343   int result;
52344
52345   {
52346     try {
52347       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
52348     } catch (std::out_of_range& e) {
52349       {
52350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52351       };
52352     } catch (std::exception& e) {
52353       {
52354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52355       };
52356     } catch (...) {
52357       {
52358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52359       };
52360     }
52361   }
52362   jresult = (int)result;
52363   return jresult;
52364 }
52365
52366
52367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
52368   int jresult ;
52369   int result;
52370
52371   {
52372     try {
52373       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
52374     } catch (std::out_of_range& e) {
52375       {
52376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52377       };
52378     } catch (std::exception& e) {
52379       {
52380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52381       };
52382     } catch (...) {
52383       {
52384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52385       };
52386     }
52387   }
52388   jresult = (int)result;
52389   return jresult;
52390 }
52391
52392
52393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
52394   int jresult ;
52395   int result;
52396
52397   {
52398     try {
52399       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
52400     } catch (std::out_of_range& e) {
52401       {
52402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52403       };
52404     } catch (std::exception& e) {
52405       {
52406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52407       };
52408     } catch (...) {
52409       {
52410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52411       };
52412     }
52413   }
52414   jresult = (int)result;
52415   return jresult;
52416 }
52417
52418 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
52419   int jresult ;
52420   int result;
52421
52422   {
52423     try {
52424       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
52425     } catch (std::out_of_range& e) {
52426       {
52427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52428       };
52429     } catch (std::exception& e) {
52430       {
52431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52432       };
52433     } catch (...) {
52434       {
52435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52436       };
52437     }
52438   }
52439   jresult = (int)result;
52440   return jresult;
52441 }
52442
52443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
52444   int jresult ;
52445   int result;
52446
52447   {
52448     try {
52449       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
52450     } catch (std::out_of_range& e) {
52451       {
52452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52453       };
52454     } catch (std::exception& e) {
52455       {
52456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52457       };
52458     } catch (...) {
52459       {
52460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52461       };
52462     }
52463   }
52464   jresult = (int)result;
52465   return jresult;
52466 }
52467
52468
52469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
52470   int jresult ;
52471   int result;
52472
52473   {
52474     try {
52475       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
52476     } catch (std::out_of_range& e) {
52477       {
52478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52479       };
52480     } catch (std::exception& e) {
52481       {
52482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52483       };
52484     } catch (...) {
52485       {
52486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52487       };
52488     }
52489   }
52490   jresult = (int)result;
52491   return jresult;
52492 }
52493
52494
52495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
52496   int jresult ;
52497   int result;
52498
52499   {
52500     try {
52501       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
52502     } catch (std::out_of_range& e) {
52503       {
52504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52505       };
52506     } catch (std::exception& e) {
52507       {
52508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52509       };
52510     } catch (...) {
52511       {
52512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52513       };
52514     }
52515   }
52516   jresult = (int)result;
52517   return jresult;
52518 }
52519
52520
52521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
52522   int jresult ;
52523   int result;
52524
52525   {
52526     try {
52527       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
52528     } catch (std::out_of_range& e) {
52529       {
52530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52531       };
52532     } catch (std::exception& e) {
52533       {
52534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52535       };
52536     } catch (...) {
52537       {
52538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52539       };
52540     }
52541   }
52542   jresult = (int)result;
52543   return jresult;
52544 }
52545
52546
52547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
52548   int jresult ;
52549   int result;
52550
52551   {
52552     try {
52553       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
52554     } catch (std::out_of_range& e) {
52555       {
52556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52557       };
52558     } catch (std::exception& e) {
52559       {
52560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52561       };
52562     } catch (...) {
52563       {
52564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52565       };
52566     }
52567   }
52568   jresult = (int)result;
52569   return jresult;
52570 }
52571
52572
52573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
52574   int jresult ;
52575   int result;
52576
52577   {
52578     try {
52579       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
52580     } catch (std::out_of_range& e) {
52581       {
52582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52583       };
52584     } catch (std::exception& e) {
52585       {
52586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52587       };
52588     } catch (...) {
52589       {
52590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52591       };
52592     }
52593   }
52594   jresult = (int)result;
52595   return jresult;
52596 }
52597
52598
52599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
52600   int jresult ;
52601   int result;
52602
52603   {
52604     try {
52605       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
52606     } catch (std::out_of_range& e) {
52607       {
52608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52609       };
52610     } catch (std::exception& e) {
52611       {
52612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52613       };
52614     } catch (...) {
52615       {
52616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52617       };
52618     }
52619   }
52620   jresult = (int)result;
52621   return jresult;
52622 }
52623
52624
52625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
52626   int jresult ;
52627   int result;
52628
52629   {
52630     try {
52631       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
52632     } catch (std::out_of_range& e) {
52633       {
52634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52635       };
52636     } catch (std::exception& e) {
52637       {
52638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52639       };
52640     } catch (...) {
52641       {
52642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52643       };
52644     }
52645   }
52646   jresult = (int)result;
52647   return jresult;
52648 }
52649
52650
52651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
52652   int jresult ;
52653   int result;
52654
52655   {
52656     try {
52657       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
52658     } catch (std::out_of_range& e) {
52659       {
52660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52661       };
52662     } catch (std::exception& e) {
52663       {
52664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52665       };
52666     } catch (...) {
52667       {
52668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52669       };
52670     }
52671   }
52672   jresult = (int)result;
52673   return jresult;
52674 }
52675
52676
52677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
52678   int jresult ;
52679   int result;
52680
52681   {
52682     try {
52683       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
52684     } catch (std::out_of_range& e) {
52685       {
52686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52687       };
52688     } catch (std::exception& e) {
52689       {
52690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52691       };
52692     } catch (...) {
52693       {
52694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52695       };
52696     }
52697   }
52698   jresult = (int)result;
52699   return jresult;
52700 }
52701
52702
52703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
52704   int jresult ;
52705   int result;
52706
52707   {
52708     try {
52709       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
52710     } catch (std::out_of_range& e) {
52711       {
52712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52713       };
52714     } catch (std::exception& e) {
52715       {
52716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52717       };
52718     } catch (...) {
52719       {
52720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52721       };
52722     }
52723   }
52724   jresult = (int)result;
52725   return jresult;
52726 }
52727
52728
52729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
52730   int jresult ;
52731   int result;
52732
52733   {
52734     try {
52735       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
52736     } catch (std::out_of_range& e) {
52737       {
52738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52739       };
52740     } catch (std::exception& e) {
52741       {
52742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52743       };
52744     } catch (...) {
52745       {
52746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52747       };
52748     }
52749   }
52750   jresult = (int)result;
52751   return jresult;
52752 }
52753
52754
52755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
52756   int jresult ;
52757   int result;
52758
52759   {
52760     try {
52761       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
52762     } catch (std::out_of_range& e) {
52763       {
52764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52765       };
52766     } catch (std::exception& e) {
52767       {
52768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52769       };
52770     } catch (...) {
52771       {
52772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52773       };
52774     }
52775   }
52776   jresult = (int)result;
52777   return jresult;
52778 }
52779
52780
52781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
52782   int jresult ;
52783   int result;
52784
52785   {
52786     try {
52787       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
52788     } catch (std::out_of_range& e) {
52789       {
52790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52791       };
52792     } catch (std::exception& e) {
52793       {
52794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52795       };
52796     } catch (...) {
52797       {
52798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52799       };
52800     }
52801   }
52802   jresult = (int)result;
52803   return jresult;
52804 }
52805
52806
52807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
52808   int jresult ;
52809   int result;
52810
52811   {
52812     try {
52813       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
52814     } catch (std::out_of_range& e) {
52815       {
52816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52817       };
52818     } catch (std::exception& e) {
52819       {
52820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52821       };
52822     } catch (...) {
52823       {
52824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52825       };
52826     }
52827   }
52828   jresult = (int)result;
52829   return jresult;
52830 }
52831
52832
52833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
52834   int jresult ;
52835   int result;
52836
52837   {
52838     try {
52839       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
52840     } catch (std::out_of_range& e) {
52841       {
52842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52843       };
52844     } catch (std::exception& e) {
52845       {
52846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52847       };
52848     } catch (...) {
52849       {
52850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52851       };
52852     }
52853   }
52854   jresult = (int)result;
52855   return jresult;
52856 }
52857
52858
52859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
52860   int jresult ;
52861   int result;
52862
52863   {
52864     try {
52865       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
52866     } catch (std::out_of_range& e) {
52867       {
52868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52869       };
52870     } catch (std::exception& e) {
52871       {
52872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52873       };
52874     } catch (...) {
52875       {
52876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52877       };
52878     }
52879   }
52880   jresult = (int)result;
52881   return jresult;
52882 }
52883
52884
52885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
52886   int jresult ;
52887   int result;
52888
52889   {
52890     try {
52891       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
52892     } catch (std::out_of_range& e) {
52893       {
52894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52895       };
52896     } catch (std::exception& e) {
52897       {
52898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52899       };
52900     } catch (...) {
52901       {
52902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52903       };
52904     }
52905   }
52906   jresult = (int)result;
52907   return jresult;
52908 }
52909
52910
52911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
52912   int jresult ;
52913   int result;
52914
52915   {
52916     try {
52917       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
52918     } catch (std::out_of_range& e) {
52919       {
52920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52921       };
52922     } catch (std::exception& e) {
52923       {
52924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52925       };
52926     } catch (...) {
52927       {
52928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52929       };
52930     }
52931   }
52932   jresult = (int)result;
52933   return jresult;
52934 }
52935
52936
52937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
52938   int jresult ;
52939   int result;
52940
52941   {
52942     try {
52943       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
52944     } catch (std::out_of_range& e) {
52945       {
52946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52947       };
52948     } catch (std::exception& e) {
52949       {
52950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52951       };
52952     } catch (...) {
52953       {
52954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52955       };
52956     }
52957   }
52958   jresult = (int)result;
52959   return jresult;
52960 }
52961
52962
52963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
52964   int jresult ;
52965   int result;
52966
52967   {
52968     try {
52969       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
52970     } catch (std::out_of_range& e) {
52971       {
52972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52973       };
52974     } catch (std::exception& e) {
52975       {
52976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52977       };
52978     } catch (...) {
52979       {
52980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52981       };
52982     }
52983   }
52984   jresult = (int)result;
52985   return jresult;
52986 }
52987
52988
52989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
52990   int jresult ;
52991   int result;
52992
52993   {
52994     try {
52995       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
52996     } catch (std::out_of_range& e) {
52997       {
52998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52999       };
53000     } catch (std::exception& e) {
53001       {
53002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53003       };
53004     } catch (...) {
53005       {
53006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53007       };
53008     }
53009   }
53010   jresult = (int)result;
53011   return jresult;
53012 }
53013
53014
53015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
53016   int jresult ;
53017   int result;
53018
53019   {
53020     try {
53021       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
53022     } catch (std::out_of_range& e) {
53023       {
53024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53025       };
53026     } catch (std::exception& e) {
53027       {
53028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53029       };
53030     } catch (...) {
53031       {
53032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53033       };
53034     }
53035   }
53036   jresult = (int)result;
53037   return jresult;
53038 }
53039
53040
53041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
53042   int jresult ;
53043   int result;
53044
53045   {
53046     try {
53047       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
53048     } catch (std::out_of_range& e) {
53049       {
53050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53051       };
53052     } catch (std::exception& e) {
53053       {
53054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53055       };
53056     } catch (...) {
53057       {
53058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53059       };
53060     }
53061   }
53062   jresult = (int)result;
53063   return jresult;
53064 }
53065
53066
53067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
53068   int jresult ;
53069   int result;
53070
53071   {
53072     try {
53073       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
53074     } catch (std::out_of_range& e) {
53075       {
53076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53077       };
53078     } catch (std::exception& e) {
53079       {
53080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53081       };
53082     } catch (...) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53085       };
53086     }
53087   }
53088   jresult = (int)result;
53089   return jresult;
53090 }
53091
53092
53093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
53094   int jresult ;
53095   int result;
53096
53097   {
53098     try {
53099       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
53100     } catch (std::out_of_range& e) {
53101       {
53102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53103       };
53104     } catch (std::exception& e) {
53105       {
53106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53107       };
53108     } catch (...) {
53109       {
53110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53111       };
53112     }
53113   }
53114   jresult = (int)result;
53115   return jresult;
53116 }
53117
53118
53119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
53120   int jresult ;
53121   int result;
53122
53123   {
53124     try {
53125       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
53126     } catch (std::out_of_range& e) {
53127       {
53128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53129       };
53130     } catch (std::exception& e) {
53131       {
53132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53133       };
53134     } catch (...) {
53135       {
53136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53137       };
53138     }
53139   }
53140   jresult = (int)result;
53141   return jresult;
53142 }
53143
53144
53145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
53146   int jresult ;
53147   int result;
53148
53149   {
53150     try {
53151       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
53152     } catch (std::out_of_range& e) {
53153       {
53154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53155       };
53156     } catch (std::exception& e) {
53157       {
53158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53159       };
53160     } catch (...) {
53161       {
53162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53163       };
53164     }
53165   }
53166   jresult = (int)result;
53167   return jresult;
53168 }
53169
53170
53171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
53172   void * jresult ;
53173   Dali::Toolkit::Builder *result = 0 ;
53174
53175   {
53176     try {
53177       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
53178     } catch (std::out_of_range& e) {
53179       {
53180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53181       };
53182     } catch (std::exception& e) {
53183       {
53184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53185       };
53186     } catch (...) {
53187       {
53188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53189       };
53190     }
53191   }
53192   jresult = (void *)result;
53193   return jresult;
53194 }
53195
53196
53197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
53198   void * jresult ;
53199   Dali::Toolkit::Builder result;
53200
53201   {
53202     try {
53203       result = Dali::Toolkit::Builder::New();
53204     } catch (std::out_of_range& e) {
53205       {
53206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53207       };
53208     } catch (std::exception& e) {
53209       {
53210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53211       };
53212     } catch (...) {
53213       {
53214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53215       };
53216     }
53217   }
53218   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
53219   return jresult;
53220 }
53221
53222
53223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
53224   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53225
53226   arg1 = (Dali::Toolkit::Builder *)jarg1;
53227   {
53228     try {
53229       delete arg1;
53230     } catch (std::out_of_range& e) {
53231       {
53232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53233       };
53234     } catch (std::exception& e) {
53235       {
53236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53237       };
53238     } catch (...) {
53239       {
53240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53241       };
53242     }
53243   }
53244 }
53245
53246
53247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
53248   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53249   std::string *arg2 = 0 ;
53250   Dali::Toolkit::Builder::UIFormat arg3 ;
53251
53252   arg1 = (Dali::Toolkit::Builder *)jarg1;
53253   if (!jarg2) {
53254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53255     return ;
53256   }
53257   std::string arg2_str(jarg2);
53258   arg2 = &arg2_str;
53259   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
53260   {
53261     try {
53262       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
53263     } catch (std::out_of_range& e) {
53264       {
53265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53266       };
53267     } catch (std::exception& e) {
53268       {
53269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53270       };
53271     } catch (...) {
53272       {
53273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53274       };
53275     }
53276   }
53277
53278   //argout typemap for const std::string&
53279
53280 }
53281
53282
53283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
53284   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53285   std::string *arg2 = 0 ;
53286
53287   arg1 = (Dali::Toolkit::Builder *)jarg1;
53288   if (!jarg2) {
53289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53290     return ;
53291   }
53292   std::string arg2_str(jarg2);
53293   arg2 = &arg2_str;
53294   {
53295     try {
53296       (arg1)->LoadFromString((std::string const &)*arg2);
53297     } catch (std::out_of_range& e) {
53298       {
53299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53300       };
53301     } catch (std::exception& e) {
53302       {
53303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53304       };
53305     } catch (...) {
53306       {
53307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53308       };
53309     }
53310   }
53311
53312   //argout typemap for const std::string&
53313
53314 }
53315
53316
53317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
53318   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53319   Dali::Property::Map *arg2 = 0 ;
53320
53321   arg1 = (Dali::Toolkit::Builder *)jarg1;
53322   arg2 = (Dali::Property::Map *)jarg2;
53323   if (!arg2) {
53324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53325     return ;
53326   }
53327   {
53328     try {
53329       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
53330     } catch (std::out_of_range& e) {
53331       {
53332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53333       };
53334     } catch (std::exception& e) {
53335       {
53336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53337       };
53338     } catch (...) {
53339       {
53340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53341       };
53342     }
53343   }
53344 }
53345
53346
53347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
53348   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53349   std::string *arg2 = 0 ;
53350   Dali::Property::Value *arg3 = 0 ;
53351
53352   arg1 = (Dali::Toolkit::Builder *)jarg1;
53353   if (!jarg2) {
53354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53355     return ;
53356   }
53357   std::string arg2_str(jarg2);
53358   arg2 = &arg2_str;
53359   arg3 = (Dali::Property::Value *)jarg3;
53360   if (!arg3) {
53361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
53362     return ;
53363   }
53364   {
53365     try {
53366       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
53367     } catch (std::out_of_range& e) {
53368       {
53369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53370       };
53371     } catch (std::exception& e) {
53372       {
53373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53374       };
53375     } catch (...) {
53376       {
53377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53378       };
53379     }
53380   }
53381
53382   //argout typemap for const std::string&
53383
53384 }
53385
53386
53387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
53388   void * jresult ;
53389   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53390   Dali::Property::Map *result = 0 ;
53391
53392   arg1 = (Dali::Toolkit::Builder *)jarg1;
53393   {
53394     try {
53395       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
53396     } catch (std::out_of_range& e) {
53397       {
53398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53399       };
53400     } catch (std::exception& e) {
53401       {
53402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53403       };
53404     } catch (...) {
53405       {
53406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53407       };
53408     }
53409   }
53410   jresult = (void *)result;
53411   return jresult;
53412 }
53413
53414
53415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
53416   void * jresult ;
53417   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53418   std::string *arg2 = 0 ;
53419   Dali::Property::Value *result = 0 ;
53420
53421   arg1 = (Dali::Toolkit::Builder *)jarg1;
53422   if (!jarg2) {
53423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53424     return 0;
53425   }
53426   std::string arg2_str(jarg2);
53427   arg2 = &arg2_str;
53428   {
53429     try {
53430       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
53431     } catch (std::out_of_range& e) {
53432       {
53433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53434       };
53435     } catch (std::exception& e) {
53436       {
53437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53438       };
53439     } catch (...) {
53440       {
53441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53442       };
53443     }
53444   }
53445   jresult = (void *)result;
53446
53447   //argout typemap for const std::string&
53448
53449   return jresult;
53450 }
53451
53452
53453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
53454   void * jresult ;
53455   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53456   std::string *arg2 = 0 ;
53457   Dali::Animation result;
53458
53459   arg1 = (Dali::Toolkit::Builder *)jarg1;
53460   if (!jarg2) {
53461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53462     return 0;
53463   }
53464   std::string arg2_str(jarg2);
53465   arg2 = &arg2_str;
53466   {
53467     try {
53468       result = (arg1)->CreateAnimation((std::string const &)*arg2);
53469     } catch (std::out_of_range& e) {
53470       {
53471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53472       };
53473     } catch (std::exception& e) {
53474       {
53475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53476       };
53477     } catch (...) {
53478       {
53479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53480       };
53481     }
53482   }
53483   jresult = new Dali::Animation((const Dali::Animation &)result);
53484
53485   //argout typemap for const std::string&
53486
53487   return jresult;
53488 }
53489
53490
53491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53492   void * jresult ;
53493   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53494   std::string *arg2 = 0 ;
53495   Dali::Property::Map *arg3 = 0 ;
53496   Dali::Animation result;
53497
53498   arg1 = (Dali::Toolkit::Builder *)jarg1;
53499   if (!jarg2) {
53500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53501     return 0;
53502   }
53503   std::string arg2_str(jarg2);
53504   arg2 = &arg2_str;
53505   arg3 = (Dali::Property::Map *)jarg3;
53506   if (!arg3) {
53507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53508     return 0;
53509   }
53510   {
53511     try {
53512       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53513     } catch (std::out_of_range& e) {
53514       {
53515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53516       };
53517     } catch (std::exception& e) {
53518       {
53519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53520       };
53521     } catch (...) {
53522       {
53523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53524       };
53525     }
53526   }
53527   jresult = new Dali::Animation((const Dali::Animation &)result);
53528
53529   //argout typemap for const std::string&
53530
53531   return jresult;
53532 }
53533
53534
53535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53536   void * jresult ;
53537   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53538   std::string *arg2 = 0 ;
53539   Dali::Actor arg3 ;
53540   Dali::Actor *argp3 ;
53541   Dali::Animation result;
53542
53543   arg1 = (Dali::Toolkit::Builder *)jarg1;
53544   if (!jarg2) {
53545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53546     return 0;
53547   }
53548   std::string arg2_str(jarg2);
53549   arg2 = &arg2_str;
53550   argp3 = (Dali::Actor *)jarg3;
53551   if (!argp3) {
53552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53553     return 0;
53554   }
53555   arg3 = *argp3;
53556   {
53557     try {
53558       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
53559     } catch (std::out_of_range& e) {
53560       {
53561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53562       };
53563     } catch (std::exception& e) {
53564       {
53565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53566       };
53567     } catch (...) {
53568       {
53569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53570       };
53571     }
53572   }
53573   jresult = new Dali::Animation((const Dali::Animation &)result);
53574
53575   //argout typemap for const std::string&
53576
53577   return jresult;
53578 }
53579
53580
53581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
53582   void * jresult ;
53583   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53584   std::string *arg2 = 0 ;
53585   Dali::Property::Map *arg3 = 0 ;
53586   Dali::Actor arg4 ;
53587   Dali::Actor *argp4 ;
53588   Dali::Animation result;
53589
53590   arg1 = (Dali::Toolkit::Builder *)jarg1;
53591   if (!jarg2) {
53592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53593     return 0;
53594   }
53595   std::string arg2_str(jarg2);
53596   arg2 = &arg2_str;
53597   arg3 = (Dali::Property::Map *)jarg3;
53598   if (!arg3) {
53599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53600     return 0;
53601   }
53602   argp4 = (Dali::Actor *)jarg4;
53603   if (!argp4) {
53604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53605     return 0;
53606   }
53607   arg4 = *argp4;
53608   {
53609     try {
53610       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
53611     } catch (std::out_of_range& e) {
53612       {
53613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53614       };
53615     } catch (std::exception& e) {
53616       {
53617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53618       };
53619     } catch (...) {
53620       {
53621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53622       };
53623     }
53624   }
53625   jresult = new Dali::Animation((const Dali::Animation &)result);
53626
53627   //argout typemap for const std::string&
53628
53629   return jresult;
53630 }
53631
53632
53633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
53634   void * jresult ;
53635   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53636   std::string *arg2 = 0 ;
53637   Dali::BaseHandle result;
53638
53639   arg1 = (Dali::Toolkit::Builder *)jarg1;
53640   if (!jarg2) {
53641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53642     return 0;
53643   }
53644   std::string arg2_str(jarg2);
53645   arg2 = &arg2_str;
53646   {
53647     try {
53648       result = (arg1)->Create((std::string const &)*arg2);
53649     } catch (std::out_of_range& e) {
53650       {
53651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53652       };
53653     } catch (std::exception& e) {
53654       {
53655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53656       };
53657     } catch (...) {
53658       {
53659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53660       };
53661     }
53662   }
53663   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53664
53665   //argout typemap for const std::string&
53666
53667   return jresult;
53668 }
53669
53670
53671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53672   void * jresult ;
53673   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53674   std::string *arg2 = 0 ;
53675   Dali::Property::Map *arg3 = 0 ;
53676   Dali::BaseHandle result;
53677
53678   arg1 = (Dali::Toolkit::Builder *)jarg1;
53679   if (!jarg2) {
53680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53681     return 0;
53682   }
53683   std::string arg2_str(jarg2);
53684   arg2 = &arg2_str;
53685   arg3 = (Dali::Property::Map *)jarg3;
53686   if (!arg3) {
53687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53688     return 0;
53689   }
53690   {
53691     try {
53692       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53693     } catch (std::out_of_range& e) {
53694       {
53695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53696       };
53697     } catch (std::exception& e) {
53698       {
53699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53700       };
53701     } catch (...) {
53702       {
53703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53704       };
53705     }
53706   }
53707   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53708
53709   //argout typemap for const std::string&
53710
53711   return jresult;
53712 }
53713
53714
53715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
53716   void * jresult ;
53717   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53718   std::string *arg2 = 0 ;
53719   Dali::BaseHandle result;
53720
53721   arg1 = (Dali::Toolkit::Builder *)jarg1;
53722   if (!jarg2) {
53723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53724     return 0;
53725   }
53726   std::string arg2_str(jarg2);
53727   arg2 = &arg2_str;
53728   {
53729     try {
53730       result = (arg1)->CreateFromJson((std::string const &)*arg2);
53731     } catch (std::out_of_range& e) {
53732       {
53733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53734       };
53735     } catch (std::exception& e) {
53736       {
53737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53738       };
53739     } catch (...) {
53740       {
53741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53742       };
53743     }
53744   }
53745   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53746
53747   //argout typemap for const std::string&
53748
53749   return jresult;
53750 }
53751
53752
53753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
53754   unsigned int jresult ;
53755   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53756   std::string *arg2 = 0 ;
53757   Dali::Handle *arg3 = 0 ;
53758   bool result;
53759
53760   arg1 = (Dali::Toolkit::Builder *)jarg1;
53761   if (!jarg2) {
53762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53763     return 0;
53764   }
53765   std::string arg2_str(jarg2);
53766   arg2 = &arg2_str;
53767   arg3 = (Dali::Handle *)jarg3;
53768   if (!arg3) {
53769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53770     return 0;
53771   }
53772   {
53773     try {
53774       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
53775     } catch (std::out_of_range& e) {
53776       {
53777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53778       };
53779     } catch (std::exception& e) {
53780       {
53781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53786       };
53787     }
53788   }
53789   jresult = result;
53790
53791   //argout typemap for const std::string&
53792
53793   return jresult;
53794 }
53795
53796
53797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
53798   unsigned int jresult ;
53799   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53800   Dali::Handle *arg2 = 0 ;
53801   std::string *arg3 = 0 ;
53802   bool result;
53803
53804   arg1 = (Dali::Toolkit::Builder *)jarg1;
53805   arg2 = (Dali::Handle *)jarg2;
53806   if (!arg2) {
53807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53808     return 0;
53809   }
53810   if (!jarg3) {
53811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53812     return 0;
53813   }
53814   std::string arg3_str(jarg3);
53815   arg3 = &arg3_str;
53816   {
53817     try {
53818       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
53819     } catch (std::out_of_range& e) {
53820       {
53821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53822       };
53823     } catch (std::exception& e) {
53824       {
53825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53826       };
53827     } catch (...) {
53828       {
53829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53830       };
53831     }
53832   }
53833   jresult = result;
53834
53835   //argout typemap for const std::string&
53836
53837   return jresult;
53838 }
53839
53840
53841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
53842   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53843   Dali::Actor arg2 ;
53844   Dali::Actor *argp2 ;
53845
53846   arg1 = (Dali::Toolkit::Builder *)jarg1;
53847   argp2 = (Dali::Actor *)jarg2;
53848   if (!argp2) {
53849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53850     return ;
53851   }
53852   arg2 = *argp2;
53853   {
53854     try {
53855       (arg1)->AddActors(arg2);
53856     } catch (std::out_of_range& e) {
53857       {
53858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53859       };
53860     } catch (std::exception& e) {
53861       {
53862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53863       };
53864     } catch (...) {
53865       {
53866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53867       };
53868     }
53869   }
53870 }
53871
53872
53873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53874   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53875   std::string *arg2 = 0 ;
53876   Dali::Actor arg3 ;
53877   Dali::Actor *argp3 ;
53878
53879   arg1 = (Dali::Toolkit::Builder *)jarg1;
53880   if (!jarg2) {
53881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53882     return ;
53883   }
53884   std::string arg2_str(jarg2);
53885   arg2 = &arg2_str;
53886   argp3 = (Dali::Actor *)jarg3;
53887   if (!argp3) {
53888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53889     return ;
53890   }
53891   arg3 = *argp3;
53892   {
53893     try {
53894       (arg1)->AddActors((std::string const &)*arg2,arg3);
53895     } catch (std::out_of_range& e) {
53896       {
53897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53898       };
53899     } catch (std::exception& e) {
53900       {
53901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53902       };
53903     } catch (...) {
53904       {
53905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53906       };
53907     }
53908   }
53909
53910   //argout typemap for const std::string&
53911
53912 }
53913
53914
53915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
53916   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53917   std::string *arg2 = 0 ;
53918
53919   arg1 = (Dali::Toolkit::Builder *)jarg1;
53920   if (!jarg2) {
53921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53922     return ;
53923   }
53924   std::string arg2_str(jarg2);
53925   arg2 = &arg2_str;
53926   {
53927     try {
53928       (arg1)->CreateRenderTask((std::string const &)*arg2);
53929     } catch (std::out_of_range& e) {
53930       {
53931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53932       };
53933     } catch (std::exception& e) {
53934       {
53935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53936       };
53937     } catch (...) {
53938       {
53939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53940       };
53941     }
53942   }
53943
53944   //argout typemap for const std::string&
53945
53946 }
53947
53948
53949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
53950   void * jresult ;
53951   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53952   std::string *arg2 = 0 ;
53953   Dali::FrameBufferImage result;
53954
53955   arg1 = (Dali::Toolkit::Builder *)jarg1;
53956   if (!jarg2) {
53957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53958     return 0;
53959   }
53960   std::string arg2_str(jarg2);
53961   arg2 = &arg2_str;
53962   {
53963     try {
53964       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
53965     } catch (std::out_of_range& e) {
53966       {
53967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53968       };
53969     } catch (std::exception& e) {
53970       {
53971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53972       };
53973     } catch (...) {
53974       {
53975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53976       };
53977     }
53978   }
53979   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
53980
53981   //argout typemap for const std::string&
53982
53983   return jresult;
53984 }
53985
53986
53987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
53988   void * jresult ;
53989   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53990   std::string *arg2 = 0 ;
53991   Dali::Path result;
53992
53993   arg1 = (Dali::Toolkit::Builder *)jarg1;
53994   if (!jarg2) {
53995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53996     return 0;
53997   }
53998   std::string arg2_str(jarg2);
53999   arg2 = &arg2_str;
54000   {
54001     try {
54002       result = (arg1)->GetPath((std::string const &)*arg2);
54003     } catch (std::out_of_range& e) {
54004       {
54005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54006       };
54007     } catch (std::exception& e) {
54008       {
54009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54010       };
54011     } catch (...) {
54012       {
54013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54014       };
54015     }
54016   }
54017   jresult = new Dali::Path((const Dali::Path &)result);
54018
54019   //argout typemap for const std::string&
54020
54021   return jresult;
54022 }
54023
54024
54025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
54026   void * jresult ;
54027   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54028   std::string *arg2 = 0 ;
54029   Dali::PathConstrainer result;
54030
54031   arg1 = (Dali::Toolkit::Builder *)jarg1;
54032   if (!jarg2) {
54033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54034     return 0;
54035   }
54036   std::string arg2_str(jarg2);
54037   arg2 = &arg2_str;
54038   {
54039     try {
54040       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
54041     } catch (std::out_of_range& e) {
54042       {
54043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54044       };
54045     } catch (std::exception& e) {
54046       {
54047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54048       };
54049     } catch (...) {
54050       {
54051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54052       };
54053     }
54054   }
54055   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
54056
54057   //argout typemap for const std::string&
54058
54059   return jresult;
54060 }
54061
54062
54063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
54064   void * jresult ;
54065   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54066   std::string *arg2 = 0 ;
54067   Dali::LinearConstrainer result;
54068
54069   arg1 = (Dali::Toolkit::Builder *)jarg1;
54070   if (!jarg2) {
54071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54072     return 0;
54073   }
54074   std::string arg2_str(jarg2);
54075   arg2 = &arg2_str;
54076   {
54077     try {
54078       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
54079     } catch (std::out_of_range& e) {
54080       {
54081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54082       };
54083     } catch (std::exception& e) {
54084       {
54085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54086       };
54087     } catch (...) {
54088       {
54089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54090       };
54091     }
54092   }
54093   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
54094
54095   //argout typemap for const std::string&
54096
54097   return jresult;
54098 }
54099
54100
54101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
54102   void * jresult ;
54103   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54104   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
54105
54106   arg1 = (Dali::Toolkit::Builder *)jarg1;
54107   {
54108     try {
54109       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
54110     } catch (std::out_of_range& e) {
54111       {
54112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54113       };
54114     } catch (std::exception& e) {
54115       {
54116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54117       };
54118     } catch (...) {
54119       {
54120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54121       };
54122     }
54123   }
54124   jresult = (void *)result;
54125   return jresult;
54126 }
54127
54128
54129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
54130   void * jresult ;
54131   Dali::Toolkit::TransitionData *result = 0 ;
54132
54133   {
54134     try {
54135       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
54136     } catch (std::out_of_range& e) {
54137       {
54138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54139       };
54140     } catch (std::exception& e) {
54141       {
54142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54143       };
54144     } catch (...) {
54145       {
54146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54147       };
54148     }
54149   }
54150   jresult = (void *)result;
54151   return jresult;
54152 }
54153
54154
54155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
54156   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54157
54158   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54159   {
54160     try {
54161       delete arg1;
54162     } catch (std::out_of_range& e) {
54163       {
54164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54165       };
54166     } catch (std::exception& e) {
54167       {
54168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54169       };
54170     } catch (...) {
54171       {
54172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54173       };
54174     }
54175   }
54176 }
54177
54178
54179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
54180   void * jresult ;
54181   Dali::Property::Map *arg1 = 0 ;
54182   Dali::Toolkit::TransitionData result;
54183
54184   arg1 = (Dali::Property::Map *)jarg1;
54185   if (!arg1) {
54186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54187     return 0;
54188   }
54189   {
54190     try {
54191       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
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 = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54207   return jresult;
54208 }
54209
54210
54211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
54212   void * jresult ;
54213   Dali::Property::Array *arg1 = 0 ;
54214   Dali::Toolkit::TransitionData result;
54215
54216   arg1 = (Dali::Property::Array *)jarg1;
54217   if (!arg1) {
54218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
54219     return 0;
54220   }
54221   {
54222     try {
54223       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
54224     } catch (std::out_of_range& e) {
54225       {
54226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54227       };
54228     } catch (std::exception& e) {
54229       {
54230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54231       };
54232     } catch (...) {
54233       {
54234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54235       };
54236     }
54237   }
54238   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54239   return jresult;
54240 }
54241
54242
54243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
54244   void * jresult ;
54245   Dali::BaseHandle arg1 ;
54246   Dali::BaseHandle *argp1 ;
54247   Dali::Toolkit::TransitionData result;
54248
54249   argp1 = (Dali::BaseHandle *)jarg1;
54250   if (!argp1) {
54251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54252     return 0;
54253   }
54254   arg1 = *argp1;
54255   {
54256     try {
54257       result = Dali::Toolkit::TransitionData::DownCast(arg1);
54258     } catch (std::out_of_range& e) {
54259       {
54260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54261       };
54262     } catch (std::exception& e) {
54263       {
54264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54265       };
54266     } catch (...) {
54267       {
54268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54269       };
54270     }
54271   }
54272   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54273   return jresult;
54274 }
54275
54276
54277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
54278   void * jresult ;
54279   Dali::Toolkit::TransitionData *arg1 = 0 ;
54280   Dali::Toolkit::TransitionData *result = 0 ;
54281
54282   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54283   if (!arg1) {
54284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54285     return 0;
54286   }
54287   {
54288     try {
54289       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
54290     } catch (std::out_of_range& e) {
54291       {
54292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54293       };
54294     } catch (std::exception& e) {
54295       {
54296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54297       };
54298     } catch (...) {
54299       {
54300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54301       };
54302     }
54303   }
54304   jresult = (void *)result;
54305   return jresult;
54306 }
54307
54308
54309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
54310   void * jresult ;
54311   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54312   Dali::Toolkit::TransitionData *arg2 = 0 ;
54313   Dali::Toolkit::TransitionData *result = 0 ;
54314
54315   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54316   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
54317   if (!arg2) {
54318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54319     return 0;
54320   }
54321   {
54322     try {
54323       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
54324     } catch (std::out_of_range& e) {
54325       {
54326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54327       };
54328     } catch (std::exception& e) {
54329       {
54330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54331       };
54332     } catch (...) {
54333       {
54334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54335       };
54336     }
54337   }
54338   jresult = (void *)result;
54339   return jresult;
54340 }
54341
54342
54343 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
54344   unsigned long jresult ;
54345   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54346   size_t result;
54347
54348   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54349   {
54350     try {
54351       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
54352     } catch (std::out_of_range& e) {
54353       {
54354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54355       };
54356     } catch (std::exception& e) {
54357       {
54358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54359       };
54360     } catch (...) {
54361       {
54362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54363       };
54364     }
54365   }
54366   jresult = (unsigned long)result;
54367   return jresult;
54368 }
54369
54370
54371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
54372   void * jresult ;
54373   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54374   size_t arg2 ;
54375   Dali::Property::Map result;
54376
54377   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54378   arg2 = (size_t)jarg2;
54379   {
54380     try {
54381       result = (arg1)->GetAnimatorAt(arg2);
54382     } catch (std::out_of_range& e) {
54383       {
54384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54385       };
54386     } catch (std::exception& e) {
54387       {
54388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54389       };
54390     } catch (...) {
54391       {
54392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54393       };
54394     }
54395   }
54396   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
54397   return jresult;
54398 }
54399
54400
54401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
54402   void * jresult ;
54403   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
54404   Dali::Toolkit::TransitionData *result = 0 ;
54405
54406   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
54407   {
54408     try {
54409       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
54410     } catch (std::out_of_range& e) {
54411       {
54412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54413       };
54414     } catch (std::exception& e) {
54415       {
54416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54417       };
54418     } catch (...) {
54419       {
54420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54421       };
54422     }
54423   }
54424   jresult = (void *)result;
54425   return jresult;
54426 }
54427
54428
54429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
54430   int jresult ;
54431   int result;
54432
54433   {
54434     try {
54435       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
54436     } catch (std::out_of_range& e) {
54437       {
54438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54439       };
54440     } catch (std::exception& e) {
54441       {
54442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54443       };
54444     } catch (...) {
54445       {
54446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54447       };
54448     }
54449   }
54450   jresult = (int)result;
54451   return jresult;
54452 }
54453
54454
54455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
54456   int jresult ;
54457   int result;
54458
54459   {
54460     try {
54461       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
54462     } catch (std::out_of_range& e) {
54463       {
54464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54465       };
54466     } catch (std::exception& e) {
54467       {
54468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54469       };
54470     } catch (...) {
54471       {
54472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54473       };
54474     }
54475   }
54476   jresult = (int)result;
54477   return jresult;
54478 }
54479
54480
54481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
54482   int jresult ;
54483   int result;
54484
54485   {
54486     try {
54487       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
54488     } catch (std::out_of_range& e) {
54489       {
54490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54491       };
54492     } catch (std::exception& e) {
54493       {
54494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54495       };
54496     } catch (...) {
54497       {
54498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54499       };
54500     }
54501   }
54502   jresult = (int)result;
54503   return jresult;
54504 }
54505
54506
54507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
54508   int jresult ;
54509   int result;
54510
54511   {
54512     try {
54513       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
54514     } catch (std::out_of_range& e) {
54515       {
54516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54517       };
54518     } catch (std::exception& e) {
54519       {
54520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54521       };
54522     } catch (...) {
54523       {
54524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54525       };
54526     }
54527   }
54528   jresult = (int)result;
54529   return jresult;
54530 }
54531
54532
54533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
54534   int jresult ;
54535   int result;
54536
54537   {
54538     try {
54539       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
54540     } catch (std::out_of_range& e) {
54541       {
54542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54543       };
54544     } catch (std::exception& e) {
54545       {
54546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54547       };
54548     } catch (...) {
54549       {
54550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54551       };
54552     }
54553   }
54554   jresult = (int)result;
54555   return jresult;
54556 }
54557
54558
54559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
54560   int jresult ;
54561   int result;
54562
54563   {
54564     try {
54565       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
54566     } catch (std::out_of_range& e) {
54567       {
54568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54569       };
54570     } catch (std::exception& e) {
54571       {
54572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54573       };
54574     } catch (...) {
54575       {
54576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54577       };
54578     }
54579   }
54580   jresult = (int)result;
54581   return jresult;
54582 }
54583
54584
54585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
54586   int jresult ;
54587   int result;
54588
54589   {
54590     try {
54591       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
54592     } catch (std::out_of_range& e) {
54593       {
54594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54595       };
54596     } catch (std::exception& e) {
54597       {
54598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54599       };
54600     } catch (...) {
54601       {
54602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54603       };
54604     }
54605   }
54606   jresult = (int)result;
54607   return jresult;
54608 }
54609
54610
54611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
54612   int jresult ;
54613   int result;
54614
54615   {
54616     try {
54617       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
54618     } catch (std::out_of_range& e) {
54619       {
54620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54621       };
54622     } catch (std::exception& e) {
54623       {
54624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54625       };
54626     } catch (...) {
54627       {
54628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54629       };
54630     }
54631   }
54632   jresult = (int)result;
54633   return jresult;
54634 }
54635
54636
54637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
54638   int jresult ;
54639   int result;
54640
54641   {
54642     try {
54643       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
54644     } catch (std::out_of_range& e) {
54645       {
54646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54647       };
54648     } catch (std::exception& e) {
54649       {
54650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54651       };
54652     } catch (...) {
54653       {
54654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54655       };
54656     }
54657   }
54658   jresult = (int)result;
54659   return jresult;
54660 }
54661
54662
54663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
54664   int jresult ;
54665   int result;
54666
54667   {
54668     try {
54669       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
54670     } catch (std::out_of_range& e) {
54671       {
54672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54673       };
54674     } catch (std::exception& e) {
54675       {
54676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54677       };
54678     } catch (...) {
54679       {
54680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54681       };
54682     }
54683   }
54684   jresult = (int)result;
54685   return jresult;
54686 }
54687
54688
54689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
54690   int jresult ;
54691   int result;
54692
54693   {
54694     try {
54695       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
54696     } catch (std::out_of_range& e) {
54697       {
54698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54699       };
54700     } catch (std::exception& e) {
54701       {
54702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54703       };
54704     } catch (...) {
54705       {
54706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54707       };
54708     }
54709   }
54710   jresult = (int)result;
54711   return jresult;
54712 }
54713
54714
54715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
54716   int jresult ;
54717   int result;
54718
54719   {
54720     try {
54721       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
54722     } catch (std::out_of_range& e) {
54723       {
54724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54725       };
54726     } catch (std::exception& e) {
54727       {
54728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54729       };
54730     } catch (...) {
54731       {
54732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54733       };
54734     }
54735   }
54736   jresult = (int)result;
54737   return jresult;
54738 }
54739
54740
54741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
54742   int jresult ;
54743   int result;
54744
54745   {
54746     try {
54747       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
54748     } catch (std::out_of_range& e) {
54749       {
54750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54751       };
54752     } catch (std::exception& e) {
54753       {
54754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54755       };
54756     } catch (...) {
54757       {
54758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54759       };
54760     }
54761   }
54762   jresult = (int)result;
54763   return jresult;
54764 }
54765
54766
54767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
54768   int jresult ;
54769   int result;
54770
54771   {
54772     try {
54773       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
54774     } catch (std::out_of_range& e) {
54775       {
54776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54777       };
54778     } catch (std::exception& e) {
54779       {
54780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54781       };
54782     } catch (...) {
54783       {
54784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54785       };
54786     }
54787   }
54788   jresult = (int)result;
54789   return jresult;
54790 }
54791
54792
54793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
54794   void * jresult ;
54795   Dali::Toolkit::Control result;
54796
54797   {
54798     try {
54799       result = Dali::Toolkit::Internal::Control::New();
54800     } catch (std::out_of_range& e) {
54801       {
54802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54803       };
54804     } catch (std::exception& e) {
54805       {
54806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54807       };
54808     } catch (...) {
54809       {
54810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54811       };
54812     }
54813   }
54814   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
54815   return jresult;
54816 }
54817
54818
54819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
54820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54821   std::string *arg2 = 0 ;
54822
54823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54824   if (!jarg2) {
54825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54826     return ;
54827   }
54828   std::string arg2_str(jarg2);
54829   arg2 = &arg2_str;
54830   {
54831     try {
54832       (arg1)->SetStyleName((std::string const &)*arg2);
54833     } catch (std::out_of_range& e) {
54834       {
54835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54836       };
54837     } catch (std::exception& e) {
54838       {
54839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54840       };
54841     } catch (...) {
54842       {
54843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54844       };
54845     }
54846   }
54847
54848   //argout typemap for const std::string&
54849
54850 }
54851
54852
54853 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
54854   char * jresult ;
54855   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54856   std::string *result = 0 ;
54857
54858   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54859   {
54860     try {
54861       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
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 = SWIG_csharp_string_callback(result->c_str());
54877   return jresult;
54878 }
54879
54880
54881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
54882   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54883   Dali::Vector4 *arg2 = 0 ;
54884
54885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54886   arg2 = (Dali::Vector4 *)jarg2;
54887   if (!arg2) {
54888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
54889     return ;
54890   }
54891   {
54892     try {
54893       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
54894     } catch (std::out_of_range& e) {
54895       {
54896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54897       };
54898     } catch (std::exception& e) {
54899       {
54900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54901       };
54902     } catch (...) {
54903       {
54904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54905       };
54906     }
54907   }
54908 }
54909
54910
54911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
54912   void * jresult ;
54913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54914   Dali::Vector4 result;
54915
54916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54917   {
54918     try {
54919       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
54920     } catch (std::out_of_range& e) {
54921       {
54922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54923       };
54924     } catch (std::exception& e) {
54925       {
54926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54927       };
54928     } catch (...) {
54929       {
54930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54931       };
54932     }
54933   }
54934   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
54935   return jresult;
54936 }
54937
54938
54939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
54940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54941   Dali::Image arg2 ;
54942   Dali::Image *argp2 ;
54943
54944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54945   argp2 = (Dali::Image *)jarg2;
54946   if (!argp2) {
54947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54948     return ;
54949   }
54950   arg2 = *argp2;
54951   {
54952     try {
54953       (arg1)->SetBackgroundImage(arg2);
54954     } catch (std::out_of_range& e) {
54955       {
54956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54957       };
54958     } catch (std::exception& e) {
54959       {
54960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54961       };
54962     } catch (...) {
54963       {
54964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54965       };
54966     }
54967   }
54968 }
54969
54970
54971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
54972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54973   Dali::Property::Map *arg2 = 0 ;
54974
54975   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54976   arg2 = (Dali::Property::Map *)jarg2;
54977   if (!arg2) {
54978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54979     return ;
54980   }
54981   {
54982     try {
54983       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
54984     } catch (std::out_of_range& e) {
54985       {
54986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54987       };
54988     } catch (std::exception& e) {
54989       {
54990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54991       };
54992     } catch (...) {
54993       {
54994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54995       };
54996     }
54997   }
54998 }
54999
55000
55001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
55002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55003
55004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55005   {
55006     try {
55007       (arg1)->ClearBackground();
55008     } catch (std::out_of_range& e) {
55009       {
55010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55011       };
55012     } catch (std::exception& e) {
55013       {
55014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55015       };
55016     } catch (...) {
55017       {
55018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55019       };
55020     }
55021   }
55022 }
55023
55024
55025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
55026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55027   Dali::Gesture::Type arg2 ;
55028
55029   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55030   arg2 = (Dali::Gesture::Type)jarg2;
55031   {
55032     try {
55033       (arg1)->EnableGestureDetection(arg2);
55034     } catch (std::out_of_range& e) {
55035       {
55036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55037       };
55038     } catch (std::exception& e) {
55039       {
55040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55041       };
55042     } catch (...) {
55043       {
55044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55045       };
55046     }
55047   }
55048 }
55049
55050
55051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
55052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55053   Dali::Gesture::Type arg2 ;
55054
55055   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55056   arg2 = (Dali::Gesture::Type)jarg2;
55057   {
55058     try {
55059       (arg1)->DisableGestureDetection(arg2);
55060     } catch (std::out_of_range& e) {
55061       {
55062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55063       };
55064     } catch (std::exception& e) {
55065       {
55066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55067       };
55068     } catch (...) {
55069       {
55070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55071       };
55072     }
55073   }
55074 }
55075
55076
55077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
55078   void * jresult ;
55079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55080   Dali::PinchGestureDetector result;
55081
55082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55083   {
55084     try {
55085       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
55086     } catch (std::out_of_range& e) {
55087       {
55088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55089       };
55090     } catch (std::exception& e) {
55091       {
55092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55093       };
55094     } catch (...) {
55095       {
55096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55097       };
55098     }
55099   }
55100   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
55101   return jresult;
55102 }
55103
55104
55105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
55106   void * jresult ;
55107   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55108   Dali::PanGestureDetector result;
55109
55110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55111   {
55112     try {
55113       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
55114     } catch (std::out_of_range& e) {
55115       {
55116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55117       };
55118     } catch (std::exception& e) {
55119       {
55120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55121       };
55122     } catch (...) {
55123       {
55124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55125       };
55126     }
55127   }
55128   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
55129   return jresult;
55130 }
55131
55132
55133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
55134   void * jresult ;
55135   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55136   Dali::TapGestureDetector result;
55137
55138   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55139   {
55140     try {
55141       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
55142     } catch (std::out_of_range& e) {
55143       {
55144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55145       };
55146     } catch (std::exception& e) {
55147       {
55148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55149       };
55150     } catch (...) {
55151       {
55152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55153       };
55154     }
55155   }
55156   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
55157   return jresult;
55158 }
55159
55160
55161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
55162   void * jresult ;
55163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55164   Dali::LongPressGestureDetector result;
55165
55166   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55167   {
55168     try {
55169       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
55170     } catch (std::out_of_range& e) {
55171       {
55172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55173       };
55174     } catch (std::exception& e) {
55175       {
55176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55177       };
55178     } catch (...) {
55179       {
55180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55181       };
55182     }
55183   }
55184   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
55185   return jresult;
55186 }
55187
55188
55189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
55190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55191   bool arg2 ;
55192
55193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55194   arg2 = jarg2 ? true : false;
55195   {
55196     try {
55197       (arg1)->SetKeyboardNavigationSupport(arg2);
55198     } catch (std::out_of_range& e) {
55199       {
55200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55201       };
55202     } catch (std::exception& e) {
55203       {
55204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55205       };
55206     } catch (...) {
55207       {
55208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55209       };
55210     }
55211   }
55212 }
55213
55214
55215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
55216   unsigned int jresult ;
55217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55218   bool result;
55219
55220   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55221   {
55222     try {
55223       result = (bool)(arg1)->IsKeyboardNavigationSupported();
55224     } catch (std::out_of_range& e) {
55225       {
55226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55227       };
55228     } catch (std::exception& e) {
55229       {
55230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55231       };
55232     } catch (...) {
55233       {
55234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55235       };
55236     }
55237   }
55238   jresult = result;
55239   return jresult;
55240 }
55241
55242
55243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
55244   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55245
55246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55247   {
55248     try {
55249       (arg1)->SetKeyInputFocus();
55250     } catch (std::out_of_range& e) {
55251       {
55252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55253       };
55254     } catch (std::exception& e) {
55255       {
55256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55257       };
55258     } catch (...) {
55259       {
55260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55261       };
55262     }
55263   }
55264 }
55265
55266
55267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
55268   unsigned int jresult ;
55269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55270   bool result;
55271
55272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55273   {
55274     try {
55275       result = (bool)(arg1)->HasKeyInputFocus();
55276     } catch (std::out_of_range& e) {
55277       {
55278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55279       };
55280     } catch (std::exception& e) {
55281       {
55282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55283       };
55284     } catch (...) {
55285       {
55286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55287       };
55288     }
55289   }
55290   jresult = result;
55291   return jresult;
55292 }
55293
55294
55295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
55296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55297
55298   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55299   {
55300     try {
55301       (arg1)->ClearKeyInputFocus();
55302     } catch (std::out_of_range& e) {
55303       {
55304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55305       };
55306     } catch (std::exception& e) {
55307       {
55308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55309       };
55310     } catch (...) {
55311       {
55312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55313       };
55314     }
55315   }
55316 }
55317
55318
55319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
55320   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55321   bool arg2 ;
55322
55323   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55324   arg2 = jarg2 ? true : false;
55325   {
55326     try {
55327       (arg1)->SetAsKeyboardFocusGroup(arg2);
55328     } catch (std::out_of_range& e) {
55329       {
55330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55331       };
55332     } catch (std::exception& e) {
55333       {
55334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55335       };
55336     } catch (...) {
55337       {
55338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55339       };
55340     }
55341   }
55342 }
55343
55344
55345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
55346   unsigned int jresult ;
55347   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55348   bool result;
55349
55350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55351   {
55352     try {
55353       result = (bool)(arg1)->IsKeyboardFocusGroup();
55354     } catch (std::out_of_range& e) {
55355       {
55356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55357       };
55358     } catch (std::exception& e) {
55359       {
55360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55361       };
55362     } catch (...) {
55363       {
55364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55365       };
55366     }
55367   }
55368   jresult = result;
55369   return jresult;
55370 }
55371
55372
55373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
55374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55375
55376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55377   {
55378     try {
55379       (arg1)->AccessibilityActivate();
55380     } catch (std::out_of_range& e) {
55381       {
55382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55383       };
55384     } catch (std::exception& e) {
55385       {
55386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55387       };
55388     } catch (...) {
55389       {
55390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55391       };
55392     }
55393   }
55394 }
55395
55396
55397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
55398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55399
55400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55401   {
55402     try {
55403       (arg1)->KeyboardEnter();
55404     } catch (std::out_of_range& e) {
55405       {
55406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55407       };
55408     } catch (std::exception& e) {
55409       {
55410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55411       };
55412     } catch (...) {
55413       {
55414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55415       };
55416     }
55417   }
55418 }
55419
55420
55421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
55422   void * jresult ;
55423   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55424   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
55425
55426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55427   {
55428     try {
55429       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
55430     } catch (std::out_of_range& e) {
55431       {
55432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55433       };
55434     } catch (std::exception& e) {
55435       {
55436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55437       };
55438     } catch (...) {
55439       {
55440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55441       };
55442     }
55443   }
55444   jresult = (void *)result;
55445   return jresult;
55446 }
55447
55448
55449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
55450   void * jresult ;
55451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55452   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55453
55454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55455   {
55456     try {
55457       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
55458     } catch (std::out_of_range& e) {
55459       {
55460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55461       };
55462     } catch (std::exception& e) {
55463       {
55464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55465       };
55466     } catch (...) {
55467       {
55468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55469       };
55470     }
55471   }
55472   jresult = (void *)result;
55473   return jresult;
55474 }
55475
55476
55477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
55478   void * jresult ;
55479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55480   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55481
55482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55483   {
55484     try {
55485       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
55486     } catch (std::out_of_range& e) {
55487       {
55488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55489       };
55490     } catch (std::exception& e) {
55491       {
55492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55493       };
55494     } catch (...) {
55495       {
55496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55497       };
55498     }
55499   }
55500   jresult = (void *)result;
55501   return jresult;
55502 }
55503
55504
55505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
55506   unsigned int jresult ;
55507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55508   Dali::KeyEvent *arg2 = 0 ;
55509   bool result;
55510
55511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55512   arg2 = (Dali::KeyEvent *)jarg2;
55513   if (!arg2) {
55514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55515     return 0;
55516   }
55517   {
55518     try {
55519       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
55520     } catch (std::out_of_range& e) {
55521       {
55522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55523       };
55524     } catch (std::exception& e) {
55525       {
55526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55527       };
55528     } catch (...) {
55529       {
55530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55531       };
55532     }
55533   }
55534   jresult = result;
55535   return jresult;
55536 }
55537
55538
55539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
55540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55541   int arg2 ;
55542   SwigDirector_ViewImpl *darg = 0;
55543
55544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55545   arg2 = (int)jarg2;
55546   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55547   {
55548     try {
55549       (darg)->OnStageConnection(arg2);
55550     } catch (std::out_of_range& e) {
55551       {
55552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55553       };
55554     } catch (std::exception& e) {
55555       {
55556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55557       };
55558     } catch (...) {
55559       {
55560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55561       };
55562     }
55563   }
55564 }
55565
55566
55567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
55568   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55569   int arg2 ;
55570   SwigDirector_ViewImpl *darg = 0;
55571
55572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55573   arg2 = (int)jarg2;
55574   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55575   {
55576     try {
55577       (darg)->OnStageConnectionSwigPublic(arg2);
55578     } catch (std::out_of_range& e) {
55579       {
55580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55581       };
55582     } catch (std::exception& e) {
55583       {
55584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55585       };
55586     } catch (...) {
55587       {
55588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55589       };
55590     }
55591   }
55592 }
55593
55594
55595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
55596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55597   SwigDirector_ViewImpl *darg = 0;
55598
55599   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55600   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55601   {
55602     try {
55603       (darg)->OnStageDisconnection();
55604     } catch (std::out_of_range& e) {
55605       {
55606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55607       };
55608     } catch (std::exception& e) {
55609       {
55610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55611       };
55612     } catch (...) {
55613       {
55614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55615       };
55616     }
55617   }
55618 }
55619
55620
55621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
55622   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55623   SwigDirector_ViewImpl *darg = 0;
55624
55625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55626   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55627   {
55628     try {
55629       (darg)->OnStageDisconnectionSwigPublic();
55630     } catch (std::out_of_range& e) {
55631       {
55632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55633       };
55634     } catch (std::exception& e) {
55635       {
55636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55637       };
55638     } catch (...) {
55639       {
55640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55641       };
55642     }
55643   }
55644 }
55645
55646
55647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
55648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55649   Dali::Actor *arg2 = 0 ;
55650   SwigDirector_ViewImpl *darg = 0;
55651
55652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55653   arg2 = (Dali::Actor *)jarg2;
55654   if (!arg2) {
55655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55656     return ;
55657   }
55658   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55659   {
55660     try {
55661       (darg)->OnChildAdd(*arg2);
55662     } catch (std::out_of_range& e) {
55663       {
55664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55665       };
55666     } catch (std::exception& e) {
55667       {
55668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55669       };
55670     } catch (...) {
55671       {
55672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55673       };
55674     }
55675   }
55676 }
55677
55678
55679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55681   Dali::Actor *arg2 = 0 ;
55682   SwigDirector_ViewImpl *darg = 0;
55683
55684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55685   arg2 = (Dali::Actor *)jarg2;
55686   if (!arg2) {
55687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55688     return ;
55689   }
55690   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55691   {
55692     try {
55693       (darg)->OnChildAddSwigPublic(*arg2);
55694     } catch (std::out_of_range& e) {
55695       {
55696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55697       };
55698     } catch (std::exception& e) {
55699       {
55700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55701       };
55702     } catch (...) {
55703       {
55704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55705       };
55706     }
55707   }
55708 }
55709
55710
55711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
55712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55713   Dali::Actor *arg2 = 0 ;
55714   SwigDirector_ViewImpl *darg = 0;
55715
55716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55717   arg2 = (Dali::Actor *)jarg2;
55718   if (!arg2) {
55719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55720     return ;
55721   }
55722   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55723   {
55724     try {
55725       (darg)->OnChildRemove(*arg2);
55726     } catch (std::out_of_range& e) {
55727       {
55728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55729       };
55730     } catch (std::exception& e) {
55731       {
55732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55733       };
55734     } catch (...) {
55735       {
55736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55737       };
55738     }
55739   }
55740 }
55741
55742
55743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55745   Dali::Actor *arg2 = 0 ;
55746   SwigDirector_ViewImpl *darg = 0;
55747
55748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55749   arg2 = (Dali::Actor *)jarg2;
55750   if (!arg2) {
55751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55752     return ;
55753   }
55754   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55755   {
55756     try {
55757       (darg)->OnChildRemoveSwigPublic(*arg2);
55758     } catch (std::out_of_range& e) {
55759       {
55760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55761       };
55762     } catch (std::exception& e) {
55763       {
55764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55765       };
55766     } catch (...) {
55767       {
55768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55769       };
55770     }
55771   }
55772 }
55773
55774
55775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
55776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55777   Dali::Property::Index arg2 ;
55778   Dali::Property::Value arg3 ;
55779   Dali::Property::Value *argp3 ;
55780   SwigDirector_ViewImpl *darg = 0;
55781
55782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55783   arg2 = (Dali::Property::Index)jarg2;
55784   argp3 = (Dali::Property::Value *)jarg3;
55785   if (!argp3) {
55786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55787     return ;
55788   }
55789   arg3 = *argp3;
55790   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55791   {
55792     try {
55793       (darg)->OnPropertySet(arg2,arg3);
55794     } catch (std::out_of_range& e) {
55795       {
55796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55797       };
55798     } catch (std::exception& e) {
55799       {
55800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55801       };
55802     } catch (...) {
55803       {
55804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55805       };
55806     }
55807   }
55808 }
55809
55810
55811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
55812   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55813   Dali::Property::Index arg2 ;
55814   Dali::Property::Value arg3 ;
55815   Dali::Property::Value *argp3 ;
55816   SwigDirector_ViewImpl *darg = 0;
55817
55818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55819   arg2 = (Dali::Property::Index)jarg2;
55820   argp3 = (Dali::Property::Value *)jarg3;
55821   if (!argp3) {
55822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55823     return ;
55824   }
55825   arg3 = *argp3;
55826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55827   {
55828     try {
55829       (darg)->OnPropertySetSwigPublic(arg2,arg3);
55830     } catch (std::out_of_range& e) {
55831       {
55832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55833       };
55834     } catch (std::exception& e) {
55835       {
55836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55837       };
55838     } catch (...) {
55839       {
55840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55841       };
55842     }
55843   }
55844 }
55845
55846
55847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
55848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55849   Dali::Vector3 *arg2 = 0 ;
55850   SwigDirector_ViewImpl *darg = 0;
55851
55852   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55853   arg2 = (Dali::Vector3 *)jarg2;
55854   if (!arg2) {
55855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55856     return ;
55857   }
55858   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55859   {
55860     try {
55861       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
55862     } catch (std::out_of_range& e) {
55863       {
55864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55865       };
55866     } catch (std::exception& e) {
55867       {
55868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55869       };
55870     } catch (...) {
55871       {
55872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55873       };
55874     }
55875   }
55876 }
55877
55878
55879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55881   Dali::Vector3 *arg2 = 0 ;
55882   SwigDirector_ViewImpl *darg = 0;
55883
55884   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55885   arg2 = (Dali::Vector3 *)jarg2;
55886   if (!arg2) {
55887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55888     return ;
55889   }
55890   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55891   {
55892     try {
55893       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
55894     } catch (std::out_of_range& e) {
55895       {
55896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55897       };
55898     } catch (std::exception& e) {
55899       {
55900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55901       };
55902     } catch (...) {
55903       {
55904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55905       };
55906     }
55907   }
55908 }
55909
55910
55911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
55912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55913   Dali::Animation *arg2 = 0 ;
55914   Dali::Vector3 *arg3 = 0 ;
55915   SwigDirector_ViewImpl *darg = 0;
55916
55917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55918   arg2 = (Dali::Animation *)jarg2;
55919   if (!arg2) {
55920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55921     return ;
55922   }
55923   arg3 = (Dali::Vector3 *)jarg3;
55924   if (!arg3) {
55925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55926     return ;
55927   }
55928   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55929   {
55930     try {
55931       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
55932     } catch (std::out_of_range& e) {
55933       {
55934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55935       };
55936     } catch (std::exception& e) {
55937       {
55938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55939       };
55940     } catch (...) {
55941       {
55942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55943       };
55944     }
55945   }
55946 }
55947
55948
55949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
55950   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55951   Dali::Animation *arg2 = 0 ;
55952   Dali::Vector3 *arg3 = 0 ;
55953   SwigDirector_ViewImpl *darg = 0;
55954
55955   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55956   arg2 = (Dali::Animation *)jarg2;
55957   if (!arg2) {
55958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
55959     return ;
55960   }
55961   arg3 = (Dali::Vector3 *)jarg3;
55962   if (!arg3) {
55963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55964     return ;
55965   }
55966   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55967   {
55968     try {
55969       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
55970     } catch (std::out_of_range& e) {
55971       {
55972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55973       };
55974     } catch (std::exception& e) {
55975       {
55976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55977       };
55978     } catch (...) {
55979       {
55980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55981       };
55982     }
55983   }
55984 }
55985
55986
55987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
55988   unsigned int jresult ;
55989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55990   Dali::TouchEvent *arg2 = 0 ;
55991   SwigDirector_ViewImpl *darg = 0;
55992   bool result;
55993
55994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55995   arg2 = (Dali::TouchEvent *)jarg2;
55996   if (!arg2) {
55997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
55998     return 0;
55999   }
56000   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56001   {
56002     try {
56003       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
56004     } catch (std::out_of_range& e) {
56005       {
56006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56007       };
56008     } catch (std::exception& e) {
56009       {
56010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56011       };
56012     } catch (...) {
56013       {
56014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56015       };
56016     }
56017   }
56018   jresult = result;
56019   return jresult;
56020 }
56021
56022
56023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56024   unsigned int jresult ;
56025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56026   Dali::TouchEvent *arg2 = 0 ;
56027   SwigDirector_ViewImpl *darg = 0;
56028   bool result;
56029
56030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56031   arg2 = (Dali::TouchEvent *)jarg2;
56032   if (!arg2) {
56033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
56034     return 0;
56035   }
56036   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56037   {
56038     try {
56039       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
56040     } catch (std::out_of_range& e) {
56041       {
56042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56043       };
56044     } catch (std::exception& e) {
56045       {
56046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56047       };
56048     } catch (...) {
56049       {
56050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56051       };
56052     }
56053   }
56054   jresult = result;
56055   return jresult;
56056 }
56057
56058
56059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
56060   unsigned int jresult ;
56061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56062   Dali::HoverEvent *arg2 = 0 ;
56063   SwigDirector_ViewImpl *darg = 0;
56064   bool result;
56065
56066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56067   arg2 = (Dali::HoverEvent *)jarg2;
56068   if (!arg2) {
56069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56070     return 0;
56071   }
56072   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56073   {
56074     try {
56075       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
56076     } catch (std::out_of_range& e) {
56077       {
56078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56079       };
56080     } catch (std::exception& e) {
56081       {
56082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56083       };
56084     } catch (...) {
56085       {
56086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56087       };
56088     }
56089   }
56090   jresult = result;
56091   return jresult;
56092 }
56093
56094
56095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56096   unsigned int jresult ;
56097   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56098   Dali::HoverEvent *arg2 = 0 ;
56099   SwigDirector_ViewImpl *darg = 0;
56100   bool result;
56101
56102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56103   arg2 = (Dali::HoverEvent *)jarg2;
56104   if (!arg2) {
56105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56106     return 0;
56107   }
56108   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56109   {
56110     try {
56111       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
56112     } catch (std::out_of_range& e) {
56113       {
56114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56115       };
56116     } catch (std::exception& e) {
56117       {
56118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56119       };
56120     } catch (...) {
56121       {
56122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56123       };
56124     }
56125   }
56126   jresult = result;
56127   return jresult;
56128 }
56129
56130
56131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
56132   unsigned int jresult ;
56133   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56134   Dali::KeyEvent *arg2 = 0 ;
56135   SwigDirector_ViewImpl *darg = 0;
56136   bool result;
56137
56138   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56139   arg2 = (Dali::KeyEvent *)jarg2;
56140   if (!arg2) {
56141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56142     return 0;
56143   }
56144   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56145   {
56146     try {
56147       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
56148     } catch (std::out_of_range& e) {
56149       {
56150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56151       };
56152     } catch (std::exception& e) {
56153       {
56154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56155       };
56156     } catch (...) {
56157       {
56158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56159       };
56160     }
56161   }
56162   jresult = result;
56163   return jresult;
56164 }
56165
56166
56167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56168   unsigned int jresult ;
56169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56170   Dali::KeyEvent *arg2 = 0 ;
56171   SwigDirector_ViewImpl *darg = 0;
56172   bool result;
56173
56174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56175   arg2 = (Dali::KeyEvent *)jarg2;
56176   if (!arg2) {
56177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56178     return 0;
56179   }
56180   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56181   {
56182     try {
56183       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
56184     } catch (std::out_of_range& e) {
56185       {
56186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56187       };
56188     } catch (std::exception& e) {
56189       {
56190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56191       };
56192     } catch (...) {
56193       {
56194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56195       };
56196     }
56197   }
56198   jresult = result;
56199   return jresult;
56200 }
56201
56202
56203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
56204   unsigned int jresult ;
56205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56206   Dali::WheelEvent *arg2 = 0 ;
56207   SwigDirector_ViewImpl *darg = 0;
56208   bool result;
56209
56210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56211   arg2 = (Dali::WheelEvent *)jarg2;
56212   if (!arg2) {
56213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56214     return 0;
56215   }
56216   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56217   {
56218     try {
56219       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
56220     } catch (std::out_of_range& e) {
56221       {
56222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56223       };
56224     } catch (std::exception& e) {
56225       {
56226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56227       };
56228     } catch (...) {
56229       {
56230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56231       };
56232     }
56233   }
56234   jresult = result;
56235   return jresult;
56236 }
56237
56238
56239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56240   unsigned int jresult ;
56241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56242   Dali::WheelEvent *arg2 = 0 ;
56243   SwigDirector_ViewImpl *darg = 0;
56244   bool result;
56245
56246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56247   arg2 = (Dali::WheelEvent *)jarg2;
56248   if (!arg2) {
56249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56250     return 0;
56251   }
56252   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56253   {
56254     try {
56255       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
56256     } catch (std::out_of_range& e) {
56257       {
56258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56259       };
56260     } catch (std::exception& e) {
56261       {
56262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56263       };
56264     } catch (...) {
56265       {
56266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56267       };
56268     }
56269   }
56270   jresult = result;
56271   return jresult;
56272 }
56273
56274
56275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
56276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56277   Dali::Vector2 *arg2 = 0 ;
56278   Dali::RelayoutContainer *arg3 = 0 ;
56279   SwigDirector_ViewImpl *darg = 0;
56280
56281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56282   arg2 = (Dali::Vector2 *)jarg2;
56283   if (!arg2) {
56284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56285     return ;
56286   }
56287   arg3 = (Dali::RelayoutContainer *)jarg3;
56288   if (!arg3) {
56289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56290     return ;
56291   }
56292   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56293   {
56294     try {
56295       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
56296     } catch (std::out_of_range& e) {
56297       {
56298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56299       };
56300     } catch (std::exception& e) {
56301       {
56302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56303       };
56304     } catch (...) {
56305       {
56306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56307       };
56308     }
56309   }
56310 }
56311
56312
56313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
56314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56315   Dali::Vector2 *arg2 = 0 ;
56316   Dali::RelayoutContainer *arg3 = 0 ;
56317   SwigDirector_ViewImpl *darg = 0;
56318
56319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56320   arg2 = (Dali::Vector2 *)jarg2;
56321   if (!arg2) {
56322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56323     return ;
56324   }
56325   arg3 = (Dali::RelayoutContainer *)jarg3;
56326   if (!arg3) {
56327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56328     return ;
56329   }
56330   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56331   {
56332     try {
56333       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
56334     } catch (std::out_of_range& e) {
56335       {
56336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56337       };
56338     } catch (std::exception& e) {
56339       {
56340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56341       };
56342     } catch (...) {
56343       {
56344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56345       };
56346     }
56347   }
56348 }
56349
56350
56351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
56352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56353   Dali::ResizePolicy::Type arg2 ;
56354   Dali::Dimension::Type arg3 ;
56355   SwigDirector_ViewImpl *darg = 0;
56356
56357   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56358   arg2 = (Dali::ResizePolicy::Type)jarg2;
56359   arg3 = (Dali::Dimension::Type)jarg3;
56360   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56361   {
56362     try {
56363       (darg)->OnSetResizePolicy(arg2,arg3);
56364     } catch (std::out_of_range& e) {
56365       {
56366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56367       };
56368     } catch (std::exception& e) {
56369       {
56370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56371       };
56372     } catch (...) {
56373       {
56374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56375       };
56376     }
56377   }
56378 }
56379
56380
56381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
56382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56383   Dali::ResizePolicy::Type arg2 ;
56384   Dali::Dimension::Type arg3 ;
56385   SwigDirector_ViewImpl *darg = 0;
56386
56387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56388   arg2 = (Dali::ResizePolicy::Type)jarg2;
56389   arg3 = (Dali::Dimension::Type)jarg3;
56390   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56391   {
56392     try {
56393       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
56394     } catch (std::out_of_range& e) {
56395       {
56396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56397       };
56398     } catch (std::exception& e) {
56399       {
56400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56401       };
56402     } catch (...) {
56403       {
56404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56405       };
56406     }
56407   }
56408 }
56409
56410
56411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
56412   void * jresult ;
56413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56414   SwigDirector_ViewImpl *darg = 0;
56415   Dali::Vector3 result;
56416
56417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56419   {
56420     try {
56421       result = (darg)->GetNaturalSize();
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::Vector3((const Dali::Vector3 &)result);
56437   return jresult;
56438 }
56439
56440
56441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
56442   void * jresult ;
56443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56444   SwigDirector_ViewImpl *darg = 0;
56445   Dali::Vector3 result;
56446
56447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56448   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56449   {
56450     try {
56451       result = (darg)->GetNaturalSizeSwigPublic();
56452     } catch (std::out_of_range& e) {
56453       {
56454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56455       };
56456     } catch (std::exception& e) {
56457       {
56458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56459       };
56460     } catch (...) {
56461       {
56462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56463       };
56464     }
56465   }
56466   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56467   return jresult;
56468 }
56469
56470
56471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
56472   float jresult ;
56473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56474   Dali::Actor *arg2 = 0 ;
56475   Dali::Dimension::Type arg3 ;
56476   SwigDirector_ViewImpl *darg = 0;
56477   float result;
56478
56479   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56480   arg2 = (Dali::Actor *)jarg2;
56481   if (!arg2) {
56482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56483     return 0;
56484   }
56485   arg3 = (Dali::Dimension::Type)jarg3;
56486   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56487   {
56488     try {
56489       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
56490     } catch (std::out_of_range& e) {
56491       {
56492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56493       };
56494     } catch (std::exception& e) {
56495       {
56496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56497       };
56498     } catch (...) {
56499       {
56500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56501       };
56502     }
56503   }
56504   jresult = result;
56505   return jresult;
56506 }
56507
56508
56509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
56510   float jresult ;
56511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56512   Dali::Actor *arg2 = 0 ;
56513   Dali::Dimension::Type arg3 ;
56514   SwigDirector_ViewImpl *darg = 0;
56515   float result;
56516
56517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56518   arg2 = (Dali::Actor *)jarg2;
56519   if (!arg2) {
56520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56521     return 0;
56522   }
56523   arg3 = (Dali::Dimension::Type)jarg3;
56524   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56525   {
56526     try {
56527       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
56528     } catch (std::out_of_range& e) {
56529       {
56530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56531       };
56532     } catch (std::exception& e) {
56533       {
56534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56535       };
56536     } catch (...) {
56537       {
56538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56539       };
56540     }
56541   }
56542   jresult = result;
56543   return jresult;
56544 }
56545
56546
56547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
56548   float jresult ;
56549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56550   float arg2 ;
56551   SwigDirector_ViewImpl *darg = 0;
56552   float result;
56553
56554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56555   arg2 = (float)jarg2;
56556   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56557   {
56558     try {
56559       result = (float)(darg)->GetHeightForWidth(arg2);
56560     } catch (std::out_of_range& e) {
56561       {
56562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56563       };
56564     } catch (std::exception& e) {
56565       {
56566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56567       };
56568     } catch (...) {
56569       {
56570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56571       };
56572     }
56573   }
56574   jresult = result;
56575   return jresult;
56576 }
56577
56578
56579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
56580   float jresult ;
56581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56582   float arg2 ;
56583   SwigDirector_ViewImpl *darg = 0;
56584   float result;
56585
56586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56587   arg2 = (float)jarg2;
56588   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56589   {
56590     try {
56591       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
56592     } catch (std::out_of_range& e) {
56593       {
56594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56595       };
56596     } catch (std::exception& e) {
56597       {
56598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56599       };
56600     } catch (...) {
56601       {
56602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56603       };
56604     }
56605   }
56606   jresult = result;
56607   return jresult;
56608 }
56609
56610
56611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
56612   float jresult ;
56613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56614   float arg2 ;
56615   SwigDirector_ViewImpl *darg = 0;
56616   float result;
56617
56618   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56619   arg2 = (float)jarg2;
56620   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56621   {
56622     try {
56623       result = (float)(darg)->GetWidthForHeight(arg2);
56624     } catch (std::out_of_range& e) {
56625       {
56626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56627       };
56628     } catch (std::exception& e) {
56629       {
56630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56631       };
56632     } catch (...) {
56633       {
56634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56635       };
56636     }
56637   }
56638   jresult = result;
56639   return jresult;
56640 }
56641
56642
56643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
56644   float jresult ;
56645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56646   float arg2 ;
56647   SwigDirector_ViewImpl *darg = 0;
56648   float result;
56649
56650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56651   arg2 = (float)jarg2;
56652   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56653   {
56654     try {
56655       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
56656     } catch (std::out_of_range& e) {
56657       {
56658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56659       };
56660     } catch (std::exception& e) {
56661       {
56662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56663       };
56664     } catch (...) {
56665       {
56666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56667       };
56668     }
56669   }
56670   jresult = result;
56671   return jresult;
56672 }
56673
56674
56675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
56676   unsigned int jresult ;
56677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56678   Dali::Dimension::Type arg2 ;
56679   SwigDirector_ViewImpl *darg = 0;
56680   bool result;
56681
56682   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56683   arg2 = (Dali::Dimension::Type)jarg2;
56684   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56685   {
56686     try {
56687       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
56688     } catch (std::out_of_range& e) {
56689       {
56690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56691       };
56692     } catch (std::exception& e) {
56693       {
56694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56695       };
56696     } catch (...) {
56697       {
56698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56699       };
56700     }
56701   }
56702   jresult = result;
56703   return jresult;
56704 }
56705
56706
56707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
56708   unsigned int jresult ;
56709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56710   Dali::Dimension::Type arg2 ;
56711   SwigDirector_ViewImpl *darg = 0;
56712   bool result;
56713
56714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56715   arg2 = (Dali::Dimension::Type)jarg2;
56716   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56717   {
56718     try {
56719       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
56720     } catch (std::out_of_range& e) {
56721       {
56722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56723       };
56724     } catch (std::exception& e) {
56725       {
56726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56727       };
56728     } catch (...) {
56729       {
56730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56731       };
56732     }
56733   }
56734   jresult = result;
56735   return jresult;
56736 }
56737
56738
56739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
56740   unsigned int jresult ;
56741   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56742   SwigDirector_ViewImpl *darg = 0;
56743   bool result;
56744
56745   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56746   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56747   {
56748     try {
56749       result = (bool)(darg)->RelayoutDependentOnChildren();
56750     } catch (std::out_of_range& e) {
56751       {
56752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56753       };
56754     } catch (std::exception& e) {
56755       {
56756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56757       };
56758     } catch (...) {
56759       {
56760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56761       };
56762     }
56763   }
56764   jresult = result;
56765   return jresult;
56766 }
56767
56768
56769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
56770   unsigned int jresult ;
56771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56772   SwigDirector_ViewImpl *darg = 0;
56773   bool result;
56774
56775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56776   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56777   {
56778     try {
56779       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
56780     } catch (std::out_of_range& e) {
56781       {
56782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56783       };
56784     } catch (std::exception& e) {
56785       {
56786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56787       };
56788     } catch (...) {
56789       {
56790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56791       };
56792     }
56793   }
56794   jresult = result;
56795   return jresult;
56796 }
56797
56798
56799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
56800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56801   Dali::Dimension::Type arg2 ;
56802   SwigDirector_ViewImpl *darg = 0;
56803
56804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56805   arg2 = (Dali::Dimension::Type)jarg2;
56806   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56807   {
56808     try {
56809       (darg)->OnCalculateRelayoutSize(arg2);
56810     } catch (std::out_of_range& e) {
56811       {
56812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56813       };
56814     } catch (std::exception& e) {
56815       {
56816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56817       };
56818     } catch (...) {
56819       {
56820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56821       };
56822     }
56823   }
56824 }
56825
56826
56827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
56828   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56829   Dali::Dimension::Type arg2 ;
56830   SwigDirector_ViewImpl *darg = 0;
56831
56832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56833   arg2 = (Dali::Dimension::Type)jarg2;
56834   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56835   {
56836     try {
56837       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
56838     } catch (std::out_of_range& e) {
56839       {
56840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56841       };
56842     } catch (std::exception& e) {
56843       {
56844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56845       };
56846     } catch (...) {
56847       {
56848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56849       };
56850     }
56851   }
56852 }
56853
56854
56855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
56856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56857   float arg2 ;
56858   Dali::Dimension::Type arg3 ;
56859   SwigDirector_ViewImpl *darg = 0;
56860
56861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56862   arg2 = (float)jarg2;
56863   arg3 = (Dali::Dimension::Type)jarg3;
56864   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56865   {
56866     try {
56867       (darg)->OnLayoutNegotiated(arg2,arg3);
56868     } catch (std::out_of_range& e) {
56869       {
56870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56871       };
56872     } catch (std::exception& e) {
56873       {
56874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56875       };
56876     } catch (...) {
56877       {
56878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56879       };
56880     }
56881   }
56882 }
56883
56884
56885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
56886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56887   float arg2 ;
56888   Dali::Dimension::Type arg3 ;
56889   SwigDirector_ViewImpl *darg = 0;
56890
56891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56892   arg2 = (float)jarg2;
56893   arg3 = (Dali::Dimension::Type)jarg3;
56894   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56895   {
56896     try {
56897       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
56898     } catch (std::out_of_range& e) {
56899       {
56900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56901       };
56902     } catch (std::exception& e) {
56903       {
56904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56905       };
56906     } catch (...) {
56907       {
56908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56909       };
56910     }
56911   }
56912 }
56913
56914
56915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
56916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56917
56918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56919   {
56920     try {
56921       (arg1)->OnInitialize();
56922     } catch (std::out_of_range& e) {
56923       {
56924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56925       };
56926     } catch (std::exception& e) {
56927       {
56928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56929       };
56930     } catch (...) {
56931       {
56932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56933       };
56934     }
56935   }
56936 }
56937
56938
56939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
56940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56941
56942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56943   {
56944     try {
56945       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
56946     } catch (std::out_of_range& e) {
56947       {
56948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56949       };
56950     } catch (std::exception& e) {
56951       {
56952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56953       };
56954     } catch (...) {
56955       {
56956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56957       };
56958     }
56959   }
56960 }
56961
56962
56963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
56964   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56965   Dali::Actor *arg2 = 0 ;
56966
56967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56968   arg2 = (Dali::Actor *)jarg2;
56969   if (!arg2) {
56970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
56971     return ;
56972   }
56973   {
56974     try {
56975       (arg1)->OnControlChildAdd(*arg2);
56976     } catch (std::out_of_range& e) {
56977       {
56978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56979       };
56980     } catch (std::exception& e) {
56981       {
56982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56983       };
56984     } catch (...) {
56985       {
56986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56987       };
56988     }
56989   }
56990 }
56991
56992
56993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56994   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56995   Dali::Actor *arg2 = 0 ;
56996
56997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56998   arg2 = (Dali::Actor *)jarg2;
56999   if (!arg2) {
57000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57001     return ;
57002   }
57003   {
57004     try {
57005       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
57006     } catch (std::out_of_range& e) {
57007       {
57008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57009       };
57010     } catch (std::exception& e) {
57011       {
57012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57013       };
57014     } catch (...) {
57015       {
57016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57017       };
57018     }
57019   }
57020 }
57021
57022
57023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
57024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57025   Dali::Actor *arg2 = 0 ;
57026
57027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57028   arg2 = (Dali::Actor *)jarg2;
57029   if (!arg2) {
57030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57031     return ;
57032   }
57033   {
57034     try {
57035       (arg1)->OnControlChildRemove(*arg2);
57036     } catch (std::out_of_range& e) {
57037       {
57038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57039       };
57040     } catch (std::exception& e) {
57041       {
57042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57043       };
57044     } catch (...) {
57045       {
57046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57047       };
57048     }
57049   }
57050 }
57051
57052
57053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57055   Dali::Actor *arg2 = 0 ;
57056
57057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57058   arg2 = (Dali::Actor *)jarg2;
57059   if (!arg2) {
57060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57061     return ;
57062   }
57063   {
57064     try {
57065       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
57066     } catch (std::out_of_range& e) {
57067       {
57068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57069       };
57070     } catch (std::exception& e) {
57071       {
57072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57073       };
57074     } catch (...) {
57075       {
57076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57077       };
57078     }
57079   }
57080 }
57081
57082
57083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
57084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57085   Dali::Toolkit::StyleManager arg2 ;
57086   Dali::StyleChange::Type arg3 ;
57087   Dali::Toolkit::StyleManager *argp2 ;
57088
57089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57090   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57091   if (!argp2) {
57092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57093     return ;
57094   }
57095   arg2 = *argp2;
57096   arg3 = (Dali::StyleChange::Type)jarg3;
57097   {
57098     try {
57099       (arg1)->OnStyleChange(arg2,arg3);
57100     } catch (std::out_of_range& e) {
57101       {
57102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57103       };
57104     } catch (std::exception& e) {
57105       {
57106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57107       };
57108     } catch (...) {
57109       {
57110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57111       };
57112     }
57113   }
57114 }
57115
57116
57117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
57118   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57119   Dali::Toolkit::StyleManager arg2 ;
57120   Dali::StyleChange::Type arg3 ;
57121   Dali::Toolkit::StyleManager *argp2 ;
57122
57123   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57124   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57125   if (!argp2) {
57126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57127     return ;
57128   }
57129   arg2 = *argp2;
57130   arg3 = (Dali::StyleChange::Type)jarg3;
57131   {
57132     try {
57133       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
57134     } catch (std::out_of_range& e) {
57135       {
57136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57137       };
57138     } catch (std::exception& e) {
57139       {
57140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57141       };
57142     } catch (...) {
57143       {
57144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57145       };
57146     }
57147   }
57148 }
57149
57150
57151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
57152   unsigned int jresult ;
57153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57154   bool result;
57155
57156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57157   {
57158     try {
57159       result = (bool)(arg1)->OnAccessibilityActivated();
57160     } catch (std::out_of_range& e) {
57161       {
57162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57163       };
57164     } catch (std::exception& e) {
57165       {
57166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57167       };
57168     } catch (...) {
57169       {
57170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57171       };
57172     }
57173   }
57174   jresult = result;
57175   return jresult;
57176 }
57177
57178
57179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
57180   unsigned int jresult ;
57181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57182   bool result;
57183
57184   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57185   {
57186     try {
57187       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
57188     } catch (std::out_of_range& e) {
57189       {
57190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57191       };
57192     } catch (std::exception& e) {
57193       {
57194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57195       };
57196     } catch (...) {
57197       {
57198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57199       };
57200     }
57201   }
57202   jresult = result;
57203   return jresult;
57204 }
57205
57206
57207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
57208   unsigned int jresult ;
57209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57210   Dali::PanGesture arg2 ;
57211   Dali::PanGesture *argp2 ;
57212   bool result;
57213
57214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57215   argp2 = (Dali::PanGesture *)jarg2;
57216   if (!argp2) {
57217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57218     return 0;
57219   }
57220   arg2 = *argp2;
57221   {
57222     try {
57223       result = (bool)(arg1)->OnAccessibilityPan(arg2);
57224     } catch (std::out_of_range& e) {
57225       {
57226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57227       };
57228     } catch (std::exception& e) {
57229       {
57230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57231       };
57232     } catch (...) {
57233       {
57234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57235       };
57236     }
57237   }
57238   jresult = result;
57239   return jresult;
57240 }
57241
57242
57243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57244   unsigned int jresult ;
57245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57246   Dali::PanGesture arg2 ;
57247   Dali::PanGesture *argp2 ;
57248   bool result;
57249
57250   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57251   argp2 = (Dali::PanGesture *)jarg2;
57252   if (!argp2) {
57253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57254     return 0;
57255   }
57256   arg2 = *argp2;
57257   {
57258     try {
57259       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
57260     } catch (std::out_of_range& e) {
57261       {
57262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57263       };
57264     } catch (std::exception& e) {
57265       {
57266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57267       };
57268     } catch (...) {
57269       {
57270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57271       };
57272     }
57273   }
57274   jresult = result;
57275   return jresult;
57276 }
57277
57278
57279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
57280   unsigned int jresult ;
57281   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57282   Dali::TouchEvent *arg2 = 0 ;
57283   bool result;
57284
57285   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57286   arg2 = (Dali::TouchEvent *)jarg2;
57287   if (!arg2) {
57288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57289     return 0;
57290   }
57291   {
57292     try {
57293       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57294     } catch (std::out_of_range& e) {
57295       {
57296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57297       };
57298     } catch (std::exception& e) {
57299       {
57300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57301       };
57302     } catch (...) {
57303       {
57304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57305       };
57306     }
57307   }
57308   jresult = result;
57309   return jresult;
57310 }
57311
57312
57313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57314   unsigned int jresult ;
57315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57316   Dali::TouchEvent *arg2 = 0 ;
57317   bool result;
57318
57319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57320   arg2 = (Dali::TouchEvent *)jarg2;
57321   if (!arg2) {
57322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57323     return 0;
57324   }
57325   {
57326     try {
57327       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57328     } catch (std::out_of_range& e) {
57329       {
57330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57331       };
57332     } catch (std::exception& e) {
57333       {
57334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57335       };
57336     } catch (...) {
57337       {
57338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57339       };
57340     }
57341   }
57342   jresult = result;
57343   return jresult;
57344 }
57345
57346
57347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
57348   unsigned int jresult ;
57349   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57350   bool arg2 ;
57351   bool result;
57352
57353   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57354   arg2 = jarg2 ? true : false;
57355   {
57356     try {
57357       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
57358     } catch (std::out_of_range& e) {
57359       {
57360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57361       };
57362     } catch (std::exception& e) {
57363       {
57364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57365       };
57366     } catch (...) {
57367       {
57368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57369       };
57370     }
57371   }
57372   jresult = result;
57373   return jresult;
57374 }
57375
57376
57377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
57378   unsigned int jresult ;
57379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57380   bool arg2 ;
57381   bool result;
57382
57383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57384   arg2 = jarg2 ? true : false;
57385   {
57386     try {
57387       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
57388     } catch (std::out_of_range& e) {
57389       {
57390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57391       };
57392     } catch (std::exception& e) {
57393       {
57394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57395       };
57396     } catch (...) {
57397       {
57398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57399       };
57400     }
57401   }
57402   jresult = result;
57403   return jresult;
57404 }
57405
57406
57407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
57408   unsigned int jresult ;
57409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57410   bool result;
57411
57412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57413   {
57414     try {
57415       result = (bool)(arg1)->OnAccessibilityZoom();
57416     } catch (std::out_of_range& e) {
57417       {
57418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57419       };
57420     } catch (std::exception& e) {
57421       {
57422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57423       };
57424     } catch (...) {
57425       {
57426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57427       };
57428     }
57429   }
57430   jresult = result;
57431   return jresult;
57432 }
57433
57434
57435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
57436   unsigned int jresult ;
57437   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57438   bool result;
57439
57440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57441   {
57442     try {
57443       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
57444     } catch (std::out_of_range& e) {
57445       {
57446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57447       };
57448     } catch (std::exception& e) {
57449       {
57450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57451       };
57452     } catch (...) {
57453       {
57454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57455       };
57456     }
57457   }
57458   jresult = result;
57459   return jresult;
57460 }
57461
57462
57463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
57464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57465
57466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57467   {
57468     try {
57469       (arg1)->OnKeyInputFocusGained();
57470     } catch (std::out_of_range& e) {
57471       {
57472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57473       };
57474     } catch (std::exception& e) {
57475       {
57476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57477       };
57478     } catch (...) {
57479       {
57480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57481       };
57482     }
57483   }
57484 }
57485
57486
57487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
57488   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57489
57490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57491   {
57492     try {
57493       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
57494     } catch (std::out_of_range& e) {
57495       {
57496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57497       };
57498     } catch (std::exception& e) {
57499       {
57500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57501       };
57502     } catch (...) {
57503       {
57504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57505       };
57506     }
57507   }
57508 }
57509
57510
57511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
57512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57513
57514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57515   {
57516     try {
57517       (arg1)->OnKeyInputFocusLost();
57518     } catch (std::out_of_range& e) {
57519       {
57520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57521       };
57522     } catch (std::exception& e) {
57523       {
57524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57525       };
57526     } catch (...) {
57527       {
57528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57529       };
57530     }
57531   }
57532 }
57533
57534
57535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
57536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57537
57538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57539   {
57540     try {
57541       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
57542     } catch (std::out_of_range& e) {
57543       {
57544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57545       };
57546     } catch (std::exception& e) {
57547       {
57548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57549       };
57550     } catch (...) {
57551       {
57552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57553       };
57554     }
57555   }
57556 }
57557
57558
57559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57560   void * jresult ;
57561   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57562   Dali::Actor arg2 ;
57563   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57564   bool arg4 ;
57565   Dali::Actor *argp2 ;
57566   Dali::Actor result;
57567
57568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57569   argp2 = (Dali::Actor *)jarg2;
57570   if (!argp2) {
57571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57572     return 0;
57573   }
57574   arg2 = *argp2;
57575   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57576   arg4 = jarg4 ? true : false;
57577   {
57578     try {
57579       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57580     } catch (std::out_of_range& e) {
57581       {
57582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57583       };
57584     } catch (std::exception& e) {
57585       {
57586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57587       };
57588     } catch (...) {
57589       {
57590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57591       };
57592     }
57593   }
57594   jresult = new Dali::Actor((const Dali::Actor &)result);
57595   return jresult;
57596 }
57597
57598
57599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57600   void * jresult ;
57601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57602   Dali::Actor arg2 ;
57603   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57604   bool arg4 ;
57605   Dali::Actor *argp2 ;
57606   Dali::Actor result;
57607
57608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57609   argp2 = (Dali::Actor *)jarg2;
57610   if (!argp2) {
57611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57612     return 0;
57613   }
57614   arg2 = *argp2;
57615   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57616   arg4 = jarg4 ? true : false;
57617   {
57618     try {
57619       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57620     } catch (std::out_of_range& e) {
57621       {
57622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57623       };
57624     } catch (std::exception& e) {
57625       {
57626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57627       };
57628     } catch (...) {
57629       {
57630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57631       };
57632     }
57633   }
57634   jresult = new Dali::Actor((const Dali::Actor &)result);
57635   return jresult;
57636 }
57637
57638
57639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
57640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57641   Dali::Actor arg2 ;
57642   Dali::Actor *argp2 ;
57643
57644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57645   argp2 = (Dali::Actor *)jarg2;
57646   if (!argp2) {
57647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57648     return ;
57649   }
57650   arg2 = *argp2;
57651   {
57652     try {
57653       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
57654     } catch (std::out_of_range& e) {
57655       {
57656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57657       };
57658     } catch (std::exception& e) {
57659       {
57660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57661       };
57662     } catch (...) {
57663       {
57664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57665       };
57666     }
57667   }
57668 }
57669
57670
57671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57673   Dali::Actor arg2 ;
57674   Dali::Actor *argp2 ;
57675
57676   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57677   argp2 = (Dali::Actor *)jarg2;
57678   if (!argp2) {
57679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57680     return ;
57681   }
57682   arg2 = *argp2;
57683   {
57684     try {
57685       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
57686     } catch (std::out_of_range& e) {
57687       {
57688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57689       };
57690     } catch (std::exception& e) {
57691       {
57692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57693       };
57694     } catch (...) {
57695       {
57696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57697       };
57698     }
57699   }
57700 }
57701
57702
57703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
57704   unsigned int jresult ;
57705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57706   bool result;
57707
57708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57709   {
57710     try {
57711       result = (bool)(arg1)->OnKeyboardEnter();
57712     } catch (std::out_of_range& e) {
57713       {
57714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57715       };
57716     } catch (std::exception& e) {
57717       {
57718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57719       };
57720     } catch (...) {
57721       {
57722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57723       };
57724     }
57725   }
57726   jresult = result;
57727   return jresult;
57728 }
57729
57730
57731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
57732   unsigned int jresult ;
57733   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57734   bool result;
57735
57736   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57737   {
57738     try {
57739       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
57740     } catch (std::out_of_range& e) {
57741       {
57742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57743       };
57744     } catch (std::exception& e) {
57745       {
57746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57747       };
57748     } catch (...) {
57749       {
57750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57751       };
57752     }
57753   }
57754   jresult = result;
57755   return jresult;
57756 }
57757
57758
57759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
57760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57761   Dali::PinchGesture *arg2 = 0 ;
57762
57763   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57764   arg2 = (Dali::PinchGesture *)jarg2;
57765   if (!arg2) {
57766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57767     return ;
57768   }
57769   {
57770     try {
57771       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
57772     } catch (std::out_of_range& e) {
57773       {
57774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57775       };
57776     } catch (std::exception& e) {
57777       {
57778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57779       };
57780     } catch (...) {
57781       {
57782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57783       };
57784     }
57785   }
57786 }
57787
57788
57789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57790   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57791   Dali::PinchGesture *arg2 = 0 ;
57792
57793   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57794   arg2 = (Dali::PinchGesture *)jarg2;
57795   if (!arg2) {
57796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57797     return ;
57798   }
57799   {
57800     try {
57801       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
57802     } catch (std::out_of_range& e) {
57803       {
57804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57805       };
57806     } catch (std::exception& e) {
57807       {
57808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57809       };
57810     } catch (...) {
57811       {
57812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57813       };
57814     }
57815   }
57816 }
57817
57818
57819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
57820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57821   Dali::PanGesture *arg2 = 0 ;
57822
57823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57824   arg2 = (Dali::PanGesture *)jarg2;
57825   if (!arg2) {
57826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57827     return ;
57828   }
57829   {
57830     try {
57831       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
57832     } catch (std::out_of_range& e) {
57833       {
57834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57835       };
57836     } catch (std::exception& e) {
57837       {
57838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57839       };
57840     } catch (...) {
57841       {
57842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57843       };
57844     }
57845   }
57846 }
57847
57848
57849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57850   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57851   Dali::PanGesture *arg2 = 0 ;
57852
57853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57854   arg2 = (Dali::PanGesture *)jarg2;
57855   if (!arg2) {
57856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57857     return ;
57858   }
57859   {
57860     try {
57861       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
57862     } catch (std::out_of_range& e) {
57863       {
57864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57865       };
57866     } catch (std::exception& e) {
57867       {
57868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57869       };
57870     } catch (...) {
57871       {
57872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57873       };
57874     }
57875   }
57876 }
57877
57878
57879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
57880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57881   Dali::TapGesture *arg2 = 0 ;
57882
57883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57884   arg2 = (Dali::TapGesture *)jarg2;
57885   if (!arg2) {
57886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57887     return ;
57888   }
57889   {
57890     try {
57891       (arg1)->OnTap((Dali::TapGesture const &)*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_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57911   Dali::TapGesture *arg2 = 0 ;
57912
57913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57914   arg2 = (Dali::TapGesture *)jarg2;
57915   if (!arg2) {
57916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57917     return ;
57918   }
57919   {
57920     try {
57921       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
57922     } catch (std::out_of_range& e) {
57923       {
57924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57925       };
57926     } catch (std::exception& e) {
57927       {
57928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57929       };
57930     } catch (...) {
57931       {
57932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57933       };
57934     }
57935   }
57936 }
57937
57938
57939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
57940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57941   Dali::LongPressGesture *arg2 = 0 ;
57942
57943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57944   arg2 = (Dali::LongPressGesture *)jarg2;
57945   if (!arg2) {
57946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57947     return ;
57948   }
57949   {
57950     try {
57951       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
57952     } catch (std::out_of_range& e) {
57953       {
57954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57955       };
57956     } catch (std::exception& e) {
57957       {
57958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57959       };
57960     } catch (...) {
57961       {
57962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57963       };
57964     }
57965   }
57966 }
57967
57968
57969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57971   Dali::LongPressGesture *arg2 = 0 ;
57972
57973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57974   arg2 = (Dali::LongPressGesture *)jarg2;
57975   if (!arg2) {
57976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
57977     return ;
57978   }
57979   {
57980     try {
57981       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
57982     } catch (std::out_of_range& e) {
57983       {
57984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57985       };
57986     } catch (std::exception& e) {
57987       {
57988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57989       };
57990     } catch (...) {
57991       {
57992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57993       };
57994     }
57995   }
57996 }
57997
57998
57999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
58000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58001   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58002   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58003
58004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58005   arg2 = (Dali::SlotObserver *)jarg2;
58006   arg3 = (Dali::CallbackBase *)jarg3;
58007   {
58008     try {
58009       (arg1)->SignalConnected(arg2,arg3);
58010     } catch (std::out_of_range& e) {
58011       {
58012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58013       };
58014     } catch (std::exception& e) {
58015       {
58016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58017       };
58018     } catch (...) {
58019       {
58020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58021       };
58022     }
58023   }
58024 }
58025
58026
58027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58029   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58030   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58031
58032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58033   arg2 = (Dali::SlotObserver *)jarg2;
58034   arg3 = (Dali::CallbackBase *)jarg3;
58035   {
58036     try {
58037       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
58038     } catch (std::out_of_range& e) {
58039       {
58040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58041       };
58042     } catch (std::exception& e) {
58043       {
58044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58045       };
58046     } catch (...) {
58047       {
58048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58049       };
58050     }
58051   }
58052 }
58053
58054
58055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58057   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58058   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58059
58060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58061   arg2 = (Dali::SlotObserver *)jarg2;
58062   arg3 = (Dali::CallbackBase *)jarg3;
58063   {
58064     try {
58065       (arg1)->SignalDisconnected(arg2,arg3);
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58073       };
58074     } catch (...) {
58075       {
58076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58077       };
58078     }
58079   }
58080 }
58081
58082
58083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58085   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58086   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58087
58088   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58089   arg2 = (Dali::SlotObserver *)jarg2;
58090   arg3 = (Dali::CallbackBase *)jarg3;
58091   {
58092     try {
58093       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
58094     } catch (std::out_of_range& e) {
58095       {
58096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58097       };
58098     } catch (std::exception& e) {
58099       {
58100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58101       };
58102     } catch (...) {
58103       {
58104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58105       };
58106     }
58107   }
58108 }
58109
58110
58111 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) {
58112   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
58113   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
58114   if (director) {
58115     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);
58116   }
58117 }
58118
58119
58120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
58121   void * jresult ;
58122   Dali::Toolkit::Control *arg1 = 0 ;
58123   Dali::Toolkit::Internal::Control *result = 0 ;
58124
58125   arg1 = (Dali::Toolkit::Control *)jarg1;
58126   if (!arg1) {
58127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58128     return 0;
58129   }
58130   {
58131     try {
58132       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
58133     } catch (std::out_of_range& e) {
58134       {
58135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58136       };
58137     } catch (std::exception& e) {
58138       {
58139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58140       };
58141     } catch (...) {
58142       {
58143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58144       };
58145     }
58146   }
58147   jresult = (void *)result;
58148   return jresult;
58149 }
58150
58151
58152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
58153   int jresult ;
58154   int result;
58155
58156   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
58157   jresult = (int)result;
58158   return jresult;
58159 }
58160
58161
58162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
58163   int jresult ;
58164   int result;
58165
58166   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
58167   jresult = (int)result;
58168   return jresult;
58169 }
58170
58171
58172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
58173   int jresult ;
58174   int result;
58175
58176   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
58177   jresult = (int)result;
58178   return jresult;
58179 }
58180
58181
58182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
58183   int jresult ;
58184   int result;
58185
58186   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
58187   jresult = (int)result;
58188   return jresult;
58189 }
58190
58191
58192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
58193   int jresult ;
58194   int result;
58195
58196   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
58197   jresult = (int)result;
58198   return jresult;
58199 }
58200
58201
58202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
58203   void * jresult ;
58204   Dali::Toolkit::Control::Property *result = 0 ;
58205
58206   {
58207     try {
58208       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
58209     } catch (std::out_of_range& e) {
58210       {
58211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58212       };
58213     } catch (std::exception& e) {
58214       {
58215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58216       };
58217     } catch (...) {
58218       {
58219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58220       };
58221     }
58222   }
58223   jresult = (void *)result;
58224   return jresult;
58225 }
58226
58227
58228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
58229   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
58230
58231   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
58232   {
58233     try {
58234       delete arg1;
58235     } catch (std::out_of_range& e) {
58236       {
58237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58238       };
58239     } catch (std::exception& e) {
58240       {
58241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58242       };
58243     } catch (...) {
58244       {
58245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58246       };
58247     }
58248   }
58249 }
58250
58251
58252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
58253   void * jresult ;
58254   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
58255
58256   {
58257     try {
58258       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
58259     } catch (std::out_of_range& e) {
58260       {
58261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58262       };
58263     } catch (std::exception& e) {
58264       {
58265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58266       };
58267     } catch (...) {
58268       {
58269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58270       };
58271     }
58272   }
58273   jresult = (void *)result;
58274   return jresult;
58275 }
58276
58277
58278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
58279   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
58280
58281   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
58282   {
58283     try {
58284       delete arg1;
58285     } catch (std::out_of_range& e) {
58286       {
58287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58288       };
58289     } catch (std::exception& e) {
58290       {
58291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58292       };
58293     } catch (...) {
58294       {
58295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58296       };
58297     }
58298   }
58299 }
58300
58301
58302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
58303   void * jresult ;
58304   Dali::Toolkit::Control result;
58305
58306   {
58307     try {
58308       result = Dali::Toolkit::Control::New();
58309     } catch (std::out_of_range& e) {
58310       {
58311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58312       };
58313     } catch (std::exception& e) {
58314       {
58315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58316       };
58317     } catch (...) {
58318       {
58319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58320       };
58321     }
58322   }
58323   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58324   return jresult;
58325 }
58326
58327
58328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
58329   void * jresult ;
58330   Dali::Toolkit::Control *result = 0 ;
58331
58332   {
58333     try {
58334       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
58335     } catch (std::out_of_range& e) {
58336       {
58337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58338       };
58339     } catch (std::exception& e) {
58340       {
58341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58342       };
58343     } catch (...) {
58344       {
58345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58346       };
58347     }
58348   }
58349   jresult = (void *)result;
58350   return jresult;
58351 }
58352
58353
58354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
58355   void * jresult ;
58356   Dali::Toolkit::Control *arg1 = 0 ;
58357   Dali::Toolkit::Control *result = 0 ;
58358
58359   arg1 = (Dali::Toolkit::Control *)jarg1;
58360   if (!arg1) {
58361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58362     return 0;
58363   }
58364   {
58365     try {
58366       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
58367     } catch (std::out_of_range& e) {
58368       {
58369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58370       };
58371     } catch (std::exception& e) {
58372       {
58373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58374       };
58375     } catch (...) {
58376       {
58377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58378       };
58379     }
58380   }
58381   jresult = (void *)result;
58382   return jresult;
58383 }
58384
58385
58386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
58387   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58388
58389   arg1 = (Dali::Toolkit::Control *)jarg1;
58390   {
58391     try {
58392       delete arg1;
58393     } catch (std::out_of_range& e) {
58394       {
58395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58396       };
58397     } catch (std::exception& e) {
58398       {
58399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58400       };
58401     } catch (...) {
58402       {
58403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58404       };
58405     }
58406   }
58407 }
58408
58409
58410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
58411   void * jresult ;
58412   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58413   Dali::Toolkit::Control *arg2 = 0 ;
58414   Dali::Toolkit::Control *result = 0 ;
58415
58416   arg1 = (Dali::Toolkit::Control *)jarg1;
58417   arg2 = (Dali::Toolkit::Control *)jarg2;
58418   if (!arg2) {
58419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58420     return 0;
58421   }
58422   {
58423     try {
58424       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
58425     } catch (std::out_of_range& e) {
58426       {
58427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58428       };
58429     } catch (std::exception& e) {
58430       {
58431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58432       };
58433     } catch (...) {
58434       {
58435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58436       };
58437     }
58438   }
58439   jresult = (void *)result;
58440   return jresult;
58441 }
58442
58443
58444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
58445   void * jresult ;
58446   Dali::BaseHandle arg1 ;
58447   Dali::BaseHandle *argp1 ;
58448   Dali::Toolkit::Control result;
58449
58450   argp1 = (Dali::BaseHandle *)jarg1;
58451   if (!argp1) {
58452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58453     return 0;
58454   }
58455   arg1 = *argp1;
58456   {
58457     try {
58458       result = Dali::Toolkit::Control::DownCast(arg1);
58459     } catch (std::out_of_range& e) {
58460       {
58461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58462       };
58463     } catch (std::exception& e) {
58464       {
58465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58466       };
58467     } catch (...) {
58468       {
58469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58470       };
58471     }
58472   }
58473   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58474   return jresult;
58475 }
58476
58477
58478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
58479   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58480
58481   arg1 = (Dali::Toolkit::Control *)jarg1;
58482   {
58483     try {
58484       (arg1)->SetKeyInputFocus();
58485     } catch (std::out_of_range& e) {
58486       {
58487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58488       };
58489     } catch (std::exception& e) {
58490       {
58491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58492       };
58493     } catch (...) {
58494       {
58495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58496       };
58497     }
58498   }
58499 }
58500
58501
58502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
58503   unsigned int jresult ;
58504   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58505   bool result;
58506
58507   arg1 = (Dali::Toolkit::Control *)jarg1;
58508   {
58509     try {
58510       result = (bool)(arg1)->HasKeyInputFocus();
58511     } catch (std::out_of_range& e) {
58512       {
58513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58514       };
58515     } catch (std::exception& e) {
58516       {
58517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58518       };
58519     } catch (...) {
58520       {
58521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58522       };
58523     }
58524   }
58525   jresult = result;
58526   return jresult;
58527 }
58528
58529
58530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
58531   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58532
58533   arg1 = (Dali::Toolkit::Control *)jarg1;
58534   {
58535     try {
58536       (arg1)->ClearKeyInputFocus();
58537     } catch (std::out_of_range& e) {
58538       {
58539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58540       };
58541     } catch (std::exception& e) {
58542       {
58543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58544       };
58545     } catch (...) {
58546       {
58547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58548       };
58549     }
58550   }
58551 }
58552
58553
58554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
58555   void * jresult ;
58556   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58557   Dali::PinchGestureDetector result;
58558
58559   arg1 = (Dali::Toolkit::Control *)jarg1;
58560   {
58561     try {
58562       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
58563     } catch (std::out_of_range& e) {
58564       {
58565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58566       };
58567     } catch (std::exception& e) {
58568       {
58569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58570       };
58571     } catch (...) {
58572       {
58573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58574       };
58575     }
58576   }
58577   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58578   return jresult;
58579 }
58580
58581
58582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
58583   void * jresult ;
58584   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58585   Dali::PanGestureDetector result;
58586
58587   arg1 = (Dali::Toolkit::Control *)jarg1;
58588   {
58589     try {
58590       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
58591     } catch (std::out_of_range& e) {
58592       {
58593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58594       };
58595     } catch (std::exception& e) {
58596       {
58597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58598       };
58599     } catch (...) {
58600       {
58601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58602       };
58603     }
58604   }
58605   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
58606   return jresult;
58607 }
58608
58609
58610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
58611   void * jresult ;
58612   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58613   Dali::TapGestureDetector result;
58614
58615   arg1 = (Dali::Toolkit::Control *)jarg1;
58616   {
58617     try {
58618       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
58619     } catch (std::out_of_range& e) {
58620       {
58621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58622       };
58623     } catch (std::exception& e) {
58624       {
58625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58626       };
58627     } catch (...) {
58628       {
58629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58630       };
58631     }
58632   }
58633   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
58634   return jresult;
58635 }
58636
58637
58638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
58639   void * jresult ;
58640   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58641   Dali::LongPressGestureDetector result;
58642
58643   arg1 = (Dali::Toolkit::Control *)jarg1;
58644   {
58645     try {
58646       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
58647     } catch (std::out_of_range& e) {
58648       {
58649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58650       };
58651     } catch (std::exception& e) {
58652       {
58653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58654       };
58655     } catch (...) {
58656       {
58657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58658       };
58659     }
58660   }
58661   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
58662   return jresult;
58663 }
58664
58665
58666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
58667   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58668   std::string *arg2 = 0 ;
58669
58670   arg1 = (Dali::Toolkit::Control *)jarg1;
58671   if (!jarg2) {
58672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58673     return ;
58674   }
58675   std::string arg2_str(jarg2);
58676   arg2 = &arg2_str;
58677   {
58678     try {
58679       (arg1)->SetStyleName((std::string const &)*arg2);
58680     } catch (std::out_of_range& e) {
58681       {
58682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58683       };
58684     } catch (std::exception& e) {
58685       {
58686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58687       };
58688     } catch (...) {
58689       {
58690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58691       };
58692     }
58693   }
58694
58695   //argout typemap for const std::string&
58696
58697 }
58698
58699
58700 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
58701   char * jresult ;
58702   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58703   std::string *result = 0 ;
58704
58705   arg1 = (Dali::Toolkit::Control *)jarg1;
58706   {
58707     try {
58708       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
58709     } catch (std::out_of_range& e) {
58710       {
58711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58712       };
58713     } catch (std::exception& e) {
58714       {
58715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58716       };
58717     } catch (...) {
58718       {
58719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58720       };
58721     }
58722   }
58723   jresult = SWIG_csharp_string_callback(result->c_str());
58724   return jresult;
58725 }
58726
58727
58728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
58729   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58730   Dali::Vector4 *arg2 = 0 ;
58731
58732   arg1 = (Dali::Toolkit::Control *)jarg1;
58733   arg2 = (Dali::Vector4 *)jarg2;
58734   if (!arg2) {
58735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58736     return ;
58737   }
58738   {
58739     try {
58740       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58741     } catch (std::out_of_range& e) {
58742       {
58743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58744       };
58745     } catch (std::exception& e) {
58746       {
58747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58748       };
58749     } catch (...) {
58750       {
58751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58752       };
58753     }
58754   }
58755 }
58756
58757
58758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
58759   void * jresult ;
58760   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58761   Dali::Vector4 result;
58762
58763   arg1 = (Dali::Toolkit::Control *)jarg1;
58764   {
58765     try {
58766       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
58767     } catch (std::out_of_range& e) {
58768       {
58769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58770       };
58771     } catch (std::exception& e) {
58772       {
58773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58774       };
58775     } catch (...) {
58776       {
58777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58778       };
58779     }
58780   }
58781   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58782   return jresult;
58783 }
58784
58785
58786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
58787   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58788   Dali::Image arg2 ;
58789   Dali::Image *argp2 ;
58790
58791   arg1 = (Dali::Toolkit::Control *)jarg1;
58792   argp2 = (Dali::Image *)jarg2;
58793   if (!argp2) {
58794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58795     return ;
58796   }
58797   arg2 = *argp2;
58798   {
58799     try {
58800       (arg1)->SetBackgroundImage(arg2);
58801     } catch (std::out_of_range& e) {
58802       {
58803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58804       };
58805     } catch (std::exception& e) {
58806       {
58807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58808       };
58809     } catch (...) {
58810       {
58811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58812       };
58813     }
58814   }
58815 }
58816
58817
58818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
58819   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58820
58821   arg1 = (Dali::Toolkit::Control *)jarg1;
58822   {
58823     try {
58824       (arg1)->ClearBackground();
58825     } catch (std::out_of_range& e) {
58826       {
58827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58828       };
58829     } catch (std::exception& e) {
58830       {
58831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58832       };
58833     } catch (...) {
58834       {
58835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58836       };
58837     }
58838   }
58839 }
58840
58841
58842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
58843   void * jresult ;
58844   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58845   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
58846
58847   arg1 = (Dali::Toolkit::Control *)jarg1;
58848   {
58849     try {
58850       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
58851     } catch (std::out_of_range& e) {
58852       {
58853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58854       };
58855     } catch (std::exception& e) {
58856       {
58857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58858       };
58859     } catch (...) {
58860       {
58861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58862       };
58863     }
58864   }
58865   jresult = (void *)result;
58866   return jresult;
58867 }
58868
58869
58870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
58871   void * jresult ;
58872   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58873   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58874
58875   arg1 = (Dali::Toolkit::Control *)jarg1;
58876   {
58877     try {
58878       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
58879     } catch (std::out_of_range& e) {
58880       {
58881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58882       };
58883     } catch (std::exception& e) {
58884       {
58885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58886       };
58887     } catch (...) {
58888       {
58889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58890       };
58891     }
58892   }
58893   jresult = (void *)result;
58894   return jresult;
58895 }
58896
58897
58898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
58899   void * jresult ;
58900   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58901   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
58902
58903   arg1 = (Dali::Toolkit::Control *)jarg1;
58904   {
58905     try {
58906       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
58907     } catch (std::out_of_range& e) {
58908       {
58909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58910       };
58911     } catch (std::exception& e) {
58912       {
58913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58914       };
58915     } catch (...) {
58916       {
58917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58918       };
58919     }
58920   }
58921   jresult = (void *)result;
58922   return jresult;
58923 }
58924
58925
58926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
58927   void * jresult ;
58928   Dali::Toolkit::Internal::Control *arg1 = 0 ;
58929   Dali::Toolkit::Control *result = 0 ;
58930
58931   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58932   if (!arg1) {
58933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
58934     return 0;
58935   }
58936   {
58937     try {
58938       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
58939     } catch (std::out_of_range& e) {
58940       {
58941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58942       };
58943     } catch (std::exception& e) {
58944       {
58945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58946       };
58947     } catch (...) {
58948       {
58949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58950       };
58951     }
58952   }
58953   jresult = (void *)result;
58954   return jresult;
58955 }
58956
58957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
58958 {
58959   void * jresult;
58960   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58961   arg1 = (Dali::Toolkit::Control *)jarg1;
58962
58963   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
58964
58965   Dali::Toolkit::TransitionData *arg2 = 0 ;
58966   Dali::Animation result;
58967
58968   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58969   if (!arg2) {
58970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58971     return 0;
58972   }
58973   {
58974     try {
58975       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
58976     } catch (std::out_of_range& e) {
58977       {
58978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58979       };
58980     } catch (std::exception& e) {
58981       {
58982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58983       };
58984     } catch (...) {
58985       {
58986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58987       };
58988     }
58989   }
58990   jresult = new Dali::Animation((const Dali::Animation &)result);
58991   return jresult;
58992 }
58993
58994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
58995   void * jresult ;
58996   Dali::Toolkit::Control *arg1 = 0 ;
58997   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
58998
58999   arg1 = (Dali::Toolkit::Control *)jarg1;
59000   if (!arg1) {
59001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
59002     return 0;
59003   }
59004   {
59005     try {
59006       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
59007     } catch (std::out_of_range& e) {
59008       {
59009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59010       };
59011     } catch (std::exception& e) {
59012       {
59013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59014       };
59015     } catch (...) {
59016       {
59017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59018       };
59019     }
59020   }
59021   jresult = (void *)result;
59022   return jresult;
59023 }
59024
59025
59026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
59027   unsigned int jresult ;
59028   Dali::Toolkit::Control *arg1 = 0 ;
59029   bool result;
59030
59031   arg1 = (Dali::Toolkit::Control *)jarg1;
59032   if (!arg1) {
59033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
59034     return 0;
59035   }
59036   {
59037     try {
59038       result = (bool)arg1->IsResourceReady();
59039     } catch (std::out_of_range& e) {
59040       {
59041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59042       };
59043     } catch (std::exception& e) {
59044       {
59045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59046       };
59047     } catch (...) {
59048       {
59049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59050       };
59051     }
59052   }
59053   jresult = result;
59054   return jresult;
59055 }
59056
59057
59058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
59059   void * jresult ;
59060   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
59061
59062   {
59063     try {
59064       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
59065     } catch (std::out_of_range& e) {
59066       {
59067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59068       };
59069     } catch (std::exception& e) {
59070       {
59071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59072       };
59073     } catch (...) {
59074       {
59075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59076       };
59077     }
59078   }
59079   jresult = (void *)result;
59080   return jresult;
59081 }
59082
59083
59084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
59085   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59086
59087   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59088   {
59089     try {
59090       delete arg1;
59091     } catch (std::out_of_range& e) {
59092       {
59093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59094       };
59095     } catch (std::exception& e) {
59096       {
59097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59098       };
59099     } catch (...) {
59100       {
59101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59102       };
59103     }
59104   }
59105 }
59106
59107
59108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
59109   void * jresult ;
59110   Dali::Toolkit::KeyInputFocusManager result;
59111
59112   {
59113     try {
59114       result = Dali::Toolkit::KeyInputFocusManager::Get();
59115     } catch (std::out_of_range& e) {
59116       {
59117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59118       };
59119     } catch (std::exception& e) {
59120       {
59121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59122       };
59123     } catch (...) {
59124       {
59125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59126       };
59127     }
59128   }
59129   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
59130   return jresult;
59131 }
59132
59133
59134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
59135   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59136   Dali::Toolkit::Control arg2 ;
59137   Dali::Toolkit::Control *argp2 ;
59138
59139   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59140   argp2 = (Dali::Toolkit::Control *)jarg2;
59141   if (!argp2) {
59142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59143     return ;
59144   }
59145   arg2 = *argp2;
59146   {
59147     try {
59148       (arg1)->SetFocus(arg2);
59149     } catch (std::out_of_range& e) {
59150       {
59151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59152       };
59153     } catch (std::exception& e) {
59154       {
59155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59156       };
59157     } catch (...) {
59158       {
59159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59160       };
59161     }
59162   }
59163 }
59164
59165
59166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
59167   void * jresult ;
59168   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59169   Dali::Toolkit::Control result;
59170
59171   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59172   {
59173     try {
59174       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
59175     } catch (std::out_of_range& e) {
59176       {
59177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59178       };
59179     } catch (std::exception& e) {
59180       {
59181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59182       };
59183     } catch (...) {
59184       {
59185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59186       };
59187     }
59188   }
59189   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59190   return jresult;
59191 }
59192
59193
59194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
59195   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59196   Dali::Toolkit::Control arg2 ;
59197   Dali::Toolkit::Control *argp2 ;
59198
59199   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59200   argp2 = (Dali::Toolkit::Control *)jarg2;
59201   if (!argp2) {
59202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59203     return ;
59204   }
59205   arg2 = *argp2;
59206   {
59207     try {
59208       (arg1)->RemoveFocus(arg2);
59209     } catch (std::out_of_range& e) {
59210       {
59211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59212       };
59213     } catch (std::exception& e) {
59214       {
59215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59216       };
59217     } catch (...) {
59218       {
59219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59220       };
59221     }
59222   }
59223 }
59224
59225
59226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
59227   void * jresult ;
59228   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59229   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
59230
59231   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59232   {
59233     try {
59234       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
59235     } catch (std::out_of_range& e) {
59236       {
59237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59238       };
59239     } catch (std::exception& e) {
59240       {
59241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59242       };
59243     } catch (...) {
59244       {
59245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59246       };
59247     }
59248   }
59249   jresult = (void *)result;
59250   return jresult;
59251 }
59252
59253
59254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
59255   void * jresult ;
59256   Dali::Toolkit::Alignment::Padding *result = 0 ;
59257
59258   {
59259     try {
59260       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
59261     } catch (std::out_of_range& e) {
59262       {
59263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59264       };
59265     } catch (std::exception& e) {
59266       {
59267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59268       };
59269     } catch (...) {
59270       {
59271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59272       };
59273     }
59274   }
59275   jresult = (void *)result;
59276   return jresult;
59277 }
59278
59279
59280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
59281   void * jresult ;
59282   float arg1 ;
59283   float arg2 ;
59284   float arg3 ;
59285   float arg4 ;
59286   Dali::Toolkit::Alignment::Padding *result = 0 ;
59287
59288   arg1 = (float)jarg1;
59289   arg2 = (float)jarg2;
59290   arg3 = (float)jarg3;
59291   arg4 = (float)jarg4;
59292   {
59293     try {
59294       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
59295     } catch (std::out_of_range& e) {
59296       {
59297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59298       };
59299     } catch (std::exception& e) {
59300       {
59301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59302       };
59303     } catch (...) {
59304       {
59305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59306       };
59307     }
59308   }
59309   jresult = (void *)result;
59310   return jresult;
59311 }
59312
59313
59314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
59315   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59316   float arg2 ;
59317
59318   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59319   arg2 = (float)jarg2;
59320   if (arg1) (arg1)->left = arg2;
59321 }
59322
59323
59324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
59325   float jresult ;
59326   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59327   float result;
59328
59329   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59330   result = (float) ((arg1)->left);
59331   jresult = result;
59332   return jresult;
59333 }
59334
59335
59336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
59337   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59338   float arg2 ;
59339
59340   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59341   arg2 = (float)jarg2;
59342   if (arg1) (arg1)->right = arg2;
59343 }
59344
59345
59346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
59347   float jresult ;
59348   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59349   float result;
59350
59351   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59352   result = (float) ((arg1)->right);
59353   jresult = result;
59354   return jresult;
59355 }
59356
59357
59358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
59359   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59360   float arg2 ;
59361
59362   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59363   arg2 = (float)jarg2;
59364   if (arg1) (arg1)->top = arg2;
59365 }
59366
59367
59368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
59369   float jresult ;
59370   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59371   float result;
59372
59373   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59374   result = (float) ((arg1)->top);
59375   jresult = result;
59376   return jresult;
59377 }
59378
59379
59380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
59381   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59382   float arg2 ;
59383
59384   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59385   arg2 = (float)jarg2;
59386   if (arg1) (arg1)->bottom = arg2;
59387 }
59388
59389
59390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
59391   float jresult ;
59392   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59393   float result;
59394
59395   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59396   result = (float) ((arg1)->bottom);
59397   jresult = result;
59398   return jresult;
59399 }
59400
59401
59402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
59403   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59404
59405   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59406   {
59407     try {
59408       delete arg1;
59409     } catch (std::out_of_range& e) {
59410       {
59411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59412       };
59413     } catch (std::exception& e) {
59414       {
59415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59416       };
59417     } catch (...) {
59418       {
59419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59420       };
59421     }
59422   }
59423 }
59424
59425
59426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
59427   void * jresult ;
59428   Dali::Toolkit::Alignment *result = 0 ;
59429
59430   {
59431     try {
59432       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
59433     } catch (std::out_of_range& e) {
59434       {
59435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59436       };
59437     } catch (std::exception& e) {
59438       {
59439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59440       };
59441     } catch (...) {
59442       {
59443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59444       };
59445     }
59446   }
59447   jresult = (void *)result;
59448   return jresult;
59449 }
59450
59451
59452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
59453   void * jresult ;
59454   Dali::Toolkit::Alignment::Type arg1 ;
59455   Dali::Toolkit::Alignment::Type arg2 ;
59456   Dali::Toolkit::Alignment result;
59457
59458   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59459   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59460   {
59461     try {
59462       result = Dali::Toolkit::Alignment::New(arg1,arg2);
59463     } catch (std::out_of_range& e) {
59464       {
59465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59466       };
59467     } catch (std::exception& e) {
59468       {
59469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59470       };
59471     } catch (...) {
59472       {
59473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59474       };
59475     }
59476   }
59477   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59478   return jresult;
59479 }
59480
59481
59482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
59483   void * jresult ;
59484   Dali::Toolkit::Alignment::Type arg1 ;
59485   Dali::Toolkit::Alignment result;
59486
59487   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59488   {
59489     try {
59490       result = Dali::Toolkit::Alignment::New(arg1);
59491     } catch (std::out_of_range& e) {
59492       {
59493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59494       };
59495     } catch (std::exception& e) {
59496       {
59497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59498       };
59499     } catch (...) {
59500       {
59501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59502       };
59503     }
59504   }
59505   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59506   return jresult;
59507 }
59508
59509
59510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
59511   void * jresult ;
59512   Dali::Toolkit::Alignment result;
59513
59514   {
59515     try {
59516       result = Dali::Toolkit::Alignment::New();
59517     } catch (std::out_of_range& e) {
59518       {
59519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59520       };
59521     } catch (std::exception& e) {
59522       {
59523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59524       };
59525     } catch (...) {
59526       {
59527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59528       };
59529     }
59530   }
59531   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59532   return jresult;
59533 }
59534
59535
59536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
59537   void * jresult ;
59538   Dali::Toolkit::Alignment *arg1 = 0 ;
59539   Dali::Toolkit::Alignment *result = 0 ;
59540
59541   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59542   if (!arg1) {
59543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59544     return 0;
59545   }
59546   {
59547     try {
59548       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
59549     } catch (std::out_of_range& e) {
59550       {
59551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59552       };
59553     } catch (std::exception& e) {
59554       {
59555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59556       };
59557     } catch (...) {
59558       {
59559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59560       };
59561     }
59562   }
59563   jresult = (void *)result;
59564   return jresult;
59565 }
59566
59567
59568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
59569   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59570
59571   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59572   {
59573     try {
59574       delete arg1;
59575     } catch (std::out_of_range& e) {
59576       {
59577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59578       };
59579     } catch (std::exception& e) {
59580       {
59581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59582       };
59583     } catch (...) {
59584       {
59585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59586       };
59587     }
59588   }
59589 }
59590
59591
59592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
59593   void * jresult ;
59594   Dali::BaseHandle arg1 ;
59595   Dali::BaseHandle *argp1 ;
59596   Dali::Toolkit::Alignment result;
59597
59598   argp1 = (Dali::BaseHandle *)jarg1;
59599   if (!argp1) {
59600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59601     return 0;
59602   }
59603   arg1 = *argp1;
59604   {
59605     try {
59606       result = Dali::Toolkit::Alignment::DownCast(arg1);
59607     } catch (std::out_of_range& e) {
59608       {
59609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59610       };
59611     } catch (std::exception& e) {
59612       {
59613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59614       };
59615     } catch (...) {
59616       {
59617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59618       };
59619     }
59620   }
59621   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59622   return jresult;
59623 }
59624
59625
59626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
59627   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59628   Dali::Toolkit::Alignment::Type arg2 ;
59629
59630   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59631   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59632   {
59633     try {
59634       (arg1)->SetAlignmentType(arg2);
59635     } catch (std::out_of_range& e) {
59636       {
59637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59638       };
59639     } catch (std::exception& e) {
59640       {
59641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59642       };
59643     } catch (...) {
59644       {
59645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59646       };
59647     }
59648   }
59649 }
59650
59651
59652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
59653   int jresult ;
59654   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59655   Dali::Toolkit::Alignment::Type result;
59656
59657   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59658   {
59659     try {
59660       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
59661     } catch (std::out_of_range& e) {
59662       {
59663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59664       };
59665     } catch (std::exception& e) {
59666       {
59667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59668       };
59669     } catch (...) {
59670       {
59671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59672       };
59673     }
59674   }
59675   jresult = (int)result;
59676   return jresult;
59677 }
59678
59679
59680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
59681   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59682   Dali::Toolkit::Alignment::Scaling arg2 ;
59683
59684   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59685   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
59686   {
59687     try {
59688       (arg1)->SetScaling(arg2);
59689     } catch (std::out_of_range& e) {
59690       {
59691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59692       };
59693     } catch (std::exception& e) {
59694       {
59695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59696       };
59697     } catch (...) {
59698       {
59699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59700       };
59701     }
59702   }
59703 }
59704
59705
59706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
59707   int jresult ;
59708   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59709   Dali::Toolkit::Alignment::Scaling result;
59710
59711   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59712   {
59713     try {
59714       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
59715     } catch (std::out_of_range& e) {
59716       {
59717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59718       };
59719     } catch (std::exception& e) {
59720       {
59721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59722       };
59723     } catch (...) {
59724       {
59725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59726       };
59727     }
59728   }
59729   jresult = (int)result;
59730   return jresult;
59731 }
59732
59733
59734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
59735   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59736   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
59737
59738   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59739   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
59740   if (!arg2) {
59741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
59742     return ;
59743   }
59744   {
59745     try {
59746       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
59747     } catch (std::out_of_range& e) {
59748       {
59749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59750       };
59751     } catch (std::exception& e) {
59752       {
59753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59754       };
59755     } catch (...) {
59756       {
59757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59758       };
59759     }
59760   }
59761 }
59762
59763
59764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
59765   void * jresult ;
59766   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59767   Dali::Toolkit::Alignment::Padding *result = 0 ;
59768
59769   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59770   {
59771     try {
59772       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
59773     } catch (std::out_of_range& e) {
59774       {
59775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59776       };
59777     } catch (std::exception& e) {
59778       {
59779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59780       };
59781     } catch (...) {
59782       {
59783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59784       };
59785     }
59786   }
59787   jresult = (void *)result;
59788   return jresult;
59789 }
59790
59791
59792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
59793   void * jresult ;
59794   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59795   Dali::Toolkit::Alignment *arg2 = 0 ;
59796   Dali::Toolkit::Alignment *result = 0 ;
59797
59798   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59799   arg2 = (Dali::Toolkit::Alignment *)jarg2;
59800   if (!arg2) {
59801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59802     return 0;
59803   }
59804   {
59805     try {
59806       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
59807     } catch (std::out_of_range& e) {
59808       {
59809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59810       };
59811     } catch (std::exception& e) {
59812       {
59813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59814       };
59815     } catch (...) {
59816       {
59817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59818       };
59819     }
59820   }
59821   jresult = (void *)result;
59822   return jresult;
59823 }
59824
59825
59826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
59827   int jresult ;
59828   int result;
59829
59830   result = (int)Dali::Toolkit::Button::Property::DISABLED;
59831   jresult = (int)result;
59832   return jresult;
59833 }
59834
59835
59836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
59837   int jresult ;
59838   int result;
59839
59840   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
59841   jresult = (int)result;
59842   return jresult;
59843 }
59844
59845
59846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
59847   int jresult ;
59848   int result;
59849
59850   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
59851   jresult = (int)result;
59852   return jresult;
59853 }
59854
59855
59856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
59857   int jresult ;
59858   int result;
59859
59860   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
59861   jresult = (int)result;
59862   return jresult;
59863 }
59864
59865
59866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
59867   int jresult ;
59868   int result;
59869
59870   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
59871   jresult = (int)result;
59872   return jresult;
59873 }
59874
59875
59876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
59877   int jresult ;
59878   int result;
59879
59880   result = (int)Dali::Toolkit::Button::Property::SELECTED;
59881   jresult = (int)result;
59882   return jresult;
59883 }
59884
59885
59886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
59887   int jresult ;
59888   int result;
59889
59890   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
59891   jresult = (int)result;
59892   return jresult;
59893 }
59894
59895
59896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
59897   int jresult ;
59898   int result;
59899
59900   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
59901   jresult = (int)result;
59902   return jresult;
59903 }
59904
59905
59906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
59907   int jresult ;
59908   int result;
59909
59910   result = (int)Dali::Toolkit::Button::Property::LABEL;
59911   jresult = (int)result;
59912   return jresult;
59913 }
59914
59915
59916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
59917   int jresult ;
59918   int result;
59919
59920   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
59921   jresult = (int)result;
59922   return jresult;
59923 }
59924
59925
59926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
59927   void * jresult ;
59928   Dali::Toolkit::Button::Property *result = 0 ;
59929
59930   {
59931     try {
59932       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
59933     } catch (std::out_of_range& e) {
59934       {
59935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59936       };
59937     } catch (std::exception& e) {
59938       {
59939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59940       };
59941     } catch (...) {
59942       {
59943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59944       };
59945     }
59946   }
59947   jresult = (void *)result;
59948   return jresult;
59949 }
59950
59951
59952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
59953   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
59954
59955   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
59956   {
59957     try {
59958       delete arg1;
59959     } catch (std::out_of_range& e) {
59960       {
59961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59962       };
59963     } catch (std::exception& e) {
59964       {
59965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59966       };
59967     } catch (...) {
59968       {
59969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59970       };
59971     }
59972   }
59973 }
59974
59975
59976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
59977   void * jresult ;
59978   Dali::Toolkit::Button *result = 0 ;
59979
59980   {
59981     try {
59982       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
59983     } catch (std::out_of_range& e) {
59984       {
59985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59986       };
59987     } catch (std::exception& e) {
59988       {
59989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59990       };
59991     } catch (...) {
59992       {
59993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59994       };
59995     }
59996   }
59997   jresult = (void *)result;
59998   return jresult;
59999 }
60000
60001
60002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
60003   void * jresult ;
60004   Dali::Toolkit::Button *arg1 = 0 ;
60005   Dali::Toolkit::Button *result = 0 ;
60006
60007   arg1 = (Dali::Toolkit::Button *)jarg1;
60008   if (!arg1) {
60009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60010     return 0;
60011   }
60012   {
60013     try {
60014       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
60015     } catch (std::out_of_range& e) {
60016       {
60017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60018       };
60019     } catch (std::exception& e) {
60020       {
60021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60022       };
60023     } catch (...) {
60024       {
60025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60026       };
60027     }
60028   }
60029   jresult = (void *)result;
60030   return jresult;
60031 }
60032
60033
60034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
60035   void * jresult ;
60036   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60037   Dali::Toolkit::Button *arg2 = 0 ;
60038   Dali::Toolkit::Button *result = 0 ;
60039
60040   arg1 = (Dali::Toolkit::Button *)jarg1;
60041   arg2 = (Dali::Toolkit::Button *)jarg2;
60042   if (!arg2) {
60043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60044     return 0;
60045   }
60046   {
60047     try {
60048       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
60049     } catch (std::out_of_range& e) {
60050       {
60051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60052       };
60053     } catch (std::exception& e) {
60054       {
60055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60056       };
60057     } catch (...) {
60058       {
60059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60060       };
60061     }
60062   }
60063   jresult = (void *)result;
60064   return jresult;
60065 }
60066
60067
60068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
60069   void * jresult ;
60070   Dali::BaseHandle arg1 ;
60071   Dali::BaseHandle *argp1 ;
60072   Dali::Toolkit::Button result;
60073
60074   argp1 = (Dali::BaseHandle *)jarg1;
60075   if (!argp1) {
60076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60077     return 0;
60078   }
60079   arg1 = *argp1;
60080   {
60081     try {
60082       result = Dali::Toolkit::Button::DownCast(arg1);
60083     } catch (std::out_of_range& e) {
60084       {
60085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60086       };
60087     } catch (std::exception& e) {
60088       {
60089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60090       };
60091     } catch (...) {
60092       {
60093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60094       };
60095     }
60096   }
60097   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
60098   return jresult;
60099 }
60100
60101
60102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
60103   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60104
60105   arg1 = (Dali::Toolkit::Button *)jarg1;
60106   {
60107     try {
60108       delete arg1;
60109     } catch (std::out_of_range& e) {
60110       {
60111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60112       };
60113     } catch (std::exception& e) {
60114       {
60115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60116       };
60117     } catch (...) {
60118       {
60119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60120       };
60121     }
60122   }
60123 }
60124
60125
60126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
60127   unsigned int jresult ;
60128   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60129   bool result;
60130
60131   arg1 = (Dali::Toolkit::Button *)jarg1;
60132   {
60133     try {
60134       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
60135     } catch (std::out_of_range& e) {
60136       {
60137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60138       };
60139     } catch (std::exception& e) {
60140       {
60141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60142       };
60143     } catch (...) {
60144       {
60145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60146       };
60147     }
60148   }
60149   jresult = result;
60150   return jresult;
60151 }
60152
60153
60154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
60155   unsigned int jresult ;
60156   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60157   bool result;
60158
60159   arg1 = (Dali::Toolkit::Button *)jarg1;
60160   {
60161     try {
60162       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
60163     } catch (std::out_of_range& e) {
60164       {
60165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60166       };
60167     } catch (std::exception& e) {
60168       {
60169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60170       };
60171     } catch (...) {
60172       {
60173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60174       };
60175     }
60176   }
60177   jresult = result;
60178   return jresult;
60179 }
60180
60181
60182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
60183   float jresult ;
60184   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60185   float result;
60186
60187   arg1 = (Dali::Toolkit::Button *)jarg1;
60188   {
60189     try {
60190       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
60191     } catch (std::out_of_range& e) {
60192       {
60193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60194       };
60195     } catch (std::exception& e) {
60196       {
60197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60198       };
60199     } catch (...) {
60200       {
60201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60202       };
60203     }
60204   }
60205   jresult = result;
60206   return jresult;
60207 }
60208
60209
60210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
60211   float jresult ;
60212   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60213   float result;
60214
60215   arg1 = (Dali::Toolkit::Button *)jarg1;
60216   {
60217     try {
60218       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
60219     } catch (std::out_of_range& e) {
60220       {
60221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60222       };
60223     } catch (std::exception& e) {
60224       {
60225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60226       };
60227     } catch (...) {
60228       {
60229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60230       };
60231     }
60232   }
60233   jresult = result;
60234   return jresult;
60235 }
60236
60237
60238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
60239   unsigned int jresult ;
60240   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60241   bool result;
60242
60243   arg1 = (Dali::Toolkit::Button *)jarg1;
60244   {
60245     try {
60246       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
60247     } catch (std::out_of_range& e) {
60248       {
60249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60250       };
60251     } catch (std::exception& e) {
60252       {
60253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60254       };
60255     } catch (...) {
60256       {
60257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60258       };
60259     }
60260   }
60261   jresult = result;
60262   return jresult;
60263 }
60264
60265
60266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
60267   unsigned int jresult ;
60268   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60269   bool result;
60270
60271   arg1 = (Dali::Toolkit::Button *)jarg1;
60272   {
60273     try {
60274       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
60275     } catch (std::out_of_range& e) {
60276       {
60277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60278       };
60279     } catch (std::exception& e) {
60280       {
60281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60282       };
60283     } catch (...) {
60284       {
60285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60286       };
60287     }
60288   }
60289   jresult = result;
60290   return jresult;
60291 }
60292
60293
60294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
60295   float jresult ;
60296   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60297   float result;
60298
60299   arg1 = (Dali::Toolkit::Button *)jarg1;
60300   {
60301     try {
60302       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
60303     } catch (std::out_of_range& e) {
60304       {
60305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60306       };
60307     } catch (std::exception& e) {
60308       {
60309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60310       };
60311     } catch (...) {
60312       {
60313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60314       };
60315     }
60316   }
60317   jresult = result;
60318   return jresult;
60319 }
60320
60321
60322 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
60323   char * jresult ;
60324   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60325   std::string result;
60326
60327   arg1 = (Dali::Toolkit::Button *)jarg1;
60328   {
60329     try {
60330       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
60331     } catch (std::out_of_range& e) {
60332       {
60333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60334       };
60335     } catch (std::exception& e) {
60336       {
60337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60338       };
60339     } catch (...) {
60340       {
60341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60342       };
60343     }
60344   }
60345   jresult = SWIG_csharp_string_callback((&result)->c_str());
60346   return jresult;
60347 }
60348
60349
60350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
60351   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60352   Dali::Actor arg2 ;
60353   Dali::Actor *argp2 ;
60354
60355   arg1 = (Dali::Toolkit::Button *)jarg1;
60356   argp2 = (Dali::Actor *)jarg2;
60357   if (!argp2) {
60358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60359     return ;
60360   }
60361   arg2 = *argp2;
60362   {
60363     try {
60364       (arg1)->SetLabel(arg2);
60365     } catch (std::out_of_range& e) {
60366       {
60367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60368       };
60369     } catch (std::exception& e) {
60370       {
60371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60372       };
60373     } catch (...) {
60374       {
60375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60376       };
60377     }
60378   }
60379 }
60380
60381
60382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
60383   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60384   Dali::Image arg2 ;
60385   Dali::Image *argp2 ;
60386
60387   arg1 = (Dali::Toolkit::Button *)jarg1;
60388   argp2 = (Dali::Image *)jarg2;
60389   if (!argp2) {
60390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60391     return ;
60392   }
60393   arg2 = *argp2;
60394   {
60395     try {
60396       (arg1)->SetButtonImage(arg2);
60397     } catch (std::out_of_range& e) {
60398       {
60399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60400       };
60401     } catch (std::exception& e) {
60402       {
60403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60404       };
60405     } catch (...) {
60406       {
60407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60408       };
60409     }
60410   }
60411 }
60412
60413
60414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
60415   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60416   Dali::Image arg2 ;
60417   Dali::Image *argp2 ;
60418
60419   arg1 = (Dali::Toolkit::Button *)jarg1;
60420   argp2 = (Dali::Image *)jarg2;
60421   if (!argp2) {
60422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60423     return ;
60424   }
60425   arg2 = *argp2;
60426   {
60427     try {
60428       (arg1)->SetSelectedImage(arg2);
60429     } catch (std::out_of_range& e) {
60430       {
60431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60432       };
60433     } catch (std::exception& e) {
60434       {
60435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60436       };
60437     } catch (...) {
60438       {
60439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60440       };
60441     }
60442   }
60443 }
60444
60445
60446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
60447   void * jresult ;
60448   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60449   Dali::Actor result;
60450
60451   arg1 = (Dali::Toolkit::Button *)jarg1;
60452   {
60453     try {
60454       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
60455     } catch (std::out_of_range& e) {
60456       {
60457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60458       };
60459     } catch (std::exception& e) {
60460       {
60461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60462       };
60463     } catch (...) {
60464       {
60465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60466       };
60467     }
60468   }
60469   jresult = new Dali::Actor((const Dali::Actor &)result);
60470   return jresult;
60471 }
60472
60473
60474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
60475   void * jresult ;
60476   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60477   Dali::Actor result;
60478
60479   arg1 = (Dali::Toolkit::Button *)jarg1;
60480   {
60481     try {
60482       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
60483     } catch (std::out_of_range& e) {
60484       {
60485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60486       };
60487     } catch (std::exception& e) {
60488       {
60489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60490       };
60491     } catch (...) {
60492       {
60493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60494       };
60495     }
60496   }
60497   jresult = new Dali::Actor((const Dali::Actor &)result);
60498   return jresult;
60499 }
60500
60501
60502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
60503   void * jresult ;
60504   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60505   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60506
60507   arg1 = (Dali::Toolkit::Button *)jarg1;
60508   {
60509     try {
60510       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
60511     } catch (std::out_of_range& e) {
60512       {
60513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60514       };
60515     } catch (std::exception& e) {
60516       {
60517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60518       };
60519     } catch (...) {
60520       {
60521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60522       };
60523     }
60524   }
60525   jresult = (void *)result;
60526   return jresult;
60527 }
60528
60529
60530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
60531   void * jresult ;
60532   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60533   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60534
60535   arg1 = (Dali::Toolkit::Button *)jarg1;
60536   {
60537     try {
60538       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
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 = (void *)result;
60554   return jresult;
60555 }
60556
60557
60558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
60559   void * jresult ;
60560   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60561   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60562
60563   arg1 = (Dali::Toolkit::Button *)jarg1;
60564   {
60565     try {
60566       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
60567     } catch (std::out_of_range& e) {
60568       {
60569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60570       };
60571     } catch (std::exception& e) {
60572       {
60573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60574       };
60575     } catch (...) {
60576       {
60577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60578       };
60579     }
60580   }
60581   jresult = (void *)result;
60582   return jresult;
60583 }
60584
60585
60586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
60587   void * jresult ;
60588   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60589   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60590
60591   arg1 = (Dali::Toolkit::Button *)jarg1;
60592   {
60593     try {
60594       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
60595     } catch (std::out_of_range& e) {
60596       {
60597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60598       };
60599     } catch (std::exception& e) {
60600       {
60601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60602       };
60603     } catch (...) {
60604       {
60605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60606       };
60607     }
60608   }
60609   jresult = (void *)result;
60610   return jresult;
60611 }
60612
60613
60614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
60615   void * jresult ;
60616   Dali::Toolkit::CheckBoxButton *result = 0 ;
60617
60618   {
60619     try {
60620       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
60621     } catch (std::out_of_range& e) {
60622       {
60623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60624       };
60625     } catch (std::exception& e) {
60626       {
60627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60628       };
60629     } catch (...) {
60630       {
60631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60632       };
60633     }
60634   }
60635   jresult = (void *)result;
60636   return jresult;
60637 }
60638
60639
60640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
60641   void * jresult ;
60642   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
60643   Dali::Toolkit::CheckBoxButton *result = 0 ;
60644
60645   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60646   if (!arg1) {
60647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60648     return 0;
60649   }
60650   {
60651     try {
60652       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
60653     } catch (std::out_of_range& e) {
60654       {
60655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60656       };
60657     } catch (std::exception& e) {
60658       {
60659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60660       };
60661     } catch (...) {
60662       {
60663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60664       };
60665     }
60666   }
60667   jresult = (void *)result;
60668   return jresult;
60669 }
60670
60671
60672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
60673   void * jresult ;
60674   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60675   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
60676   Dali::Toolkit::CheckBoxButton *result = 0 ;
60677
60678   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60679   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
60680   if (!arg2) {
60681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60682     return 0;
60683   }
60684   {
60685     try {
60686       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
60687     } catch (std::out_of_range& e) {
60688       {
60689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60690       };
60691     } catch (std::exception& e) {
60692       {
60693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60694       };
60695     } catch (...) {
60696       {
60697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60698       };
60699     }
60700   }
60701   jresult = (void *)result;
60702   return jresult;
60703 }
60704
60705
60706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
60707   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60708
60709   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60710   {
60711     try {
60712       delete arg1;
60713     } catch (std::out_of_range& e) {
60714       {
60715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60716       };
60717     } catch (std::exception& e) {
60718       {
60719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60720       };
60721     } catch (...) {
60722       {
60723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60724       };
60725     }
60726   }
60727 }
60728
60729
60730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
60731   void * jresult ;
60732   Dali::Toolkit::CheckBoxButton result;
60733
60734   {
60735     try {
60736       result = Dali::Toolkit::CheckBoxButton::New();
60737     } catch (std::out_of_range& e) {
60738       {
60739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60740       };
60741     } catch (std::exception& e) {
60742       {
60743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60744       };
60745     } catch (...) {
60746       {
60747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60748       };
60749     }
60750   }
60751   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60752   return jresult;
60753 }
60754
60755
60756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
60757   void * jresult ;
60758   Dali::BaseHandle arg1 ;
60759   Dali::BaseHandle *argp1 ;
60760   Dali::Toolkit::CheckBoxButton result;
60761
60762   argp1 = (Dali::BaseHandle *)jarg1;
60763   if (!argp1) {
60764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60765     return 0;
60766   }
60767   arg1 = *argp1;
60768   {
60769     try {
60770       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
60771     } catch (std::out_of_range& e) {
60772       {
60773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60774       };
60775     } catch (std::exception& e) {
60776       {
60777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60778       };
60779     } catch (...) {
60780       {
60781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60782       };
60783     }
60784   }
60785   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60786   return jresult;
60787 }
60788
60789
60790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
60791   int jresult ;
60792   int result;
60793
60794   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
60795   jresult = (int)result;
60796   return jresult;
60797 }
60798
60799
60800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
60801   int jresult ;
60802   int result;
60803
60804   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
60805   jresult = (int)result;
60806   return jresult;
60807 }
60808
60809
60810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
60811   int jresult ;
60812   int result;
60813
60814   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
60815   jresult = (int)result;
60816   return jresult;
60817 }
60818
60819
60820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
60821   int jresult ;
60822   int result;
60823
60824   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
60825   jresult = (int)result;
60826   return jresult;
60827 }
60828
60829
60830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
60831   int jresult ;
60832   int result;
60833
60834   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
60835   jresult = (int)result;
60836   return jresult;
60837 }
60838
60839
60840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
60841   void * jresult ;
60842   Dali::Toolkit::PushButton::Property *result = 0 ;
60843
60844   {
60845     try {
60846       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
60847     } catch (std::out_of_range& e) {
60848       {
60849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60850       };
60851     } catch (std::exception& e) {
60852       {
60853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60854       };
60855     } catch (...) {
60856       {
60857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60858       };
60859     }
60860   }
60861   jresult = (void *)result;
60862   return jresult;
60863 }
60864
60865
60866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
60867   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
60868
60869   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
60870   {
60871     try {
60872       delete arg1;
60873     } catch (std::out_of_range& e) {
60874       {
60875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60876       };
60877     } catch (std::exception& e) {
60878       {
60879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60880       };
60881     } catch (...) {
60882       {
60883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60884       };
60885     }
60886   }
60887 }
60888
60889
60890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
60891   void * jresult ;
60892   Dali::Toolkit::PushButton *result = 0 ;
60893
60894   {
60895     try {
60896       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
60897     } catch (std::out_of_range& e) {
60898       {
60899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60900       };
60901     } catch (std::exception& e) {
60902       {
60903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60904       };
60905     } catch (...) {
60906       {
60907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60908       };
60909     }
60910   }
60911   jresult = (void *)result;
60912   return jresult;
60913 }
60914
60915
60916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
60917   void * jresult ;
60918   Dali::Toolkit::PushButton *arg1 = 0 ;
60919   Dali::Toolkit::PushButton *result = 0 ;
60920
60921   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60922   if (!arg1) {
60923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60924     return 0;
60925   }
60926   {
60927     try {
60928       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
60929     } catch (std::out_of_range& e) {
60930       {
60931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60932       };
60933     } catch (std::exception& e) {
60934       {
60935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60936       };
60937     } catch (...) {
60938       {
60939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60940       };
60941     }
60942   }
60943   jresult = (void *)result;
60944   return jresult;
60945 }
60946
60947
60948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
60949   void * jresult ;
60950   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60951   Dali::Toolkit::PushButton *arg2 = 0 ;
60952   Dali::Toolkit::PushButton *result = 0 ;
60953
60954   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60955   arg2 = (Dali::Toolkit::PushButton *)jarg2;
60956   if (!arg2) {
60957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
60958     return 0;
60959   }
60960   {
60961     try {
60962       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
60963     } catch (std::out_of_range& e) {
60964       {
60965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60966       };
60967     } catch (std::exception& e) {
60968       {
60969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60970       };
60971     } catch (...) {
60972       {
60973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60974       };
60975     }
60976   }
60977   jresult = (void *)result;
60978   return jresult;
60979 }
60980
60981
60982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
60983   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
60984
60985   arg1 = (Dali::Toolkit::PushButton *)jarg1;
60986   {
60987     try {
60988       delete arg1;
60989     } catch (std::out_of_range& e) {
60990       {
60991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60992       };
60993     } catch (std::exception& e) {
60994       {
60995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60996       };
60997     } catch (...) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61000       };
61001     }
61002   }
61003 }
61004
61005
61006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
61007   void * jresult ;
61008   Dali::Toolkit::PushButton result;
61009
61010   {
61011     try {
61012       result = Dali::Toolkit::PushButton::New();
61013     } catch (std::out_of_range& e) {
61014       {
61015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61016       };
61017     } catch (std::exception& e) {
61018       {
61019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61020       };
61021     } catch (...) {
61022       {
61023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61024       };
61025     }
61026   }
61027   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61028   return jresult;
61029 }
61030
61031
61032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
61033   void * jresult ;
61034   Dali::BaseHandle arg1 ;
61035   Dali::BaseHandle *argp1 ;
61036   Dali::Toolkit::PushButton result;
61037
61038   argp1 = (Dali::BaseHandle *)jarg1;
61039   if (!argp1) {
61040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61041     return 0;
61042   }
61043   arg1 = *argp1;
61044   {
61045     try {
61046       result = Dali::Toolkit::PushButton::DownCast(arg1);
61047     } catch (std::out_of_range& e) {
61048       {
61049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61050       };
61051     } catch (std::exception& e) {
61052       {
61053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61054       };
61055     } catch (...) {
61056       {
61057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61058       };
61059     }
61060   }
61061   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61062   return jresult;
61063 }
61064
61065
61066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
61067   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61068   Dali::Image arg2 ;
61069   Dali::Image *argp2 ;
61070
61071   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61072   argp2 = (Dali::Image *)jarg2;
61073   if (!argp2) {
61074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61075     return ;
61076   }
61077   arg2 = *argp2;
61078   {
61079     try {
61080       (arg1)->SetButtonImage(arg2);
61081     } catch (std::out_of_range& e) {
61082       {
61083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61084       };
61085     } catch (std::exception& e) {
61086       {
61087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61088       };
61089     } catch (...) {
61090       {
61091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61092       };
61093     }
61094   }
61095 }
61096
61097
61098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
61099   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61100   Dali::Actor arg2 ;
61101   Dali::Actor *argp2 ;
61102
61103   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61104   argp2 = (Dali::Actor *)jarg2;
61105   if (!argp2) {
61106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61107     return ;
61108   }
61109   arg2 = *argp2;
61110   {
61111     try {
61112       (arg1)->SetButtonImage(arg2);
61113     } catch (std::out_of_range& e) {
61114       {
61115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61116       };
61117     } catch (std::exception& e) {
61118       {
61119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61120       };
61121     } catch (...) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61124       };
61125     }
61126   }
61127 }
61128
61129
61130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
61131   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61132   Dali::Actor arg2 ;
61133   Dali::Actor *argp2 ;
61134
61135   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61136   argp2 = (Dali::Actor *)jarg2;
61137   if (!argp2) {
61138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61139     return ;
61140   }
61141   arg2 = *argp2;
61142   {
61143     try {
61144       (arg1)->SetBackgroundImage(arg2);
61145     } catch (std::out_of_range& e) {
61146       {
61147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61148       };
61149     } catch (std::exception& e) {
61150       {
61151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61152       };
61153     } catch (...) {
61154       {
61155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61156       };
61157     }
61158   }
61159 }
61160
61161
61162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
61163   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61164   Dali::Image arg2 ;
61165   Dali::Image *argp2 ;
61166
61167   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61168   argp2 = (Dali::Image *)jarg2;
61169   if (!argp2) {
61170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61171     return ;
61172   }
61173   arg2 = *argp2;
61174   {
61175     try {
61176       (arg1)->SetSelectedImage(arg2);
61177     } catch (std::out_of_range& e) {
61178       {
61179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61180       };
61181     } catch (std::exception& e) {
61182       {
61183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61184       };
61185     } catch (...) {
61186       {
61187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61188       };
61189     }
61190   }
61191 }
61192
61193
61194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
61195   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61196   Dali::Actor arg2 ;
61197   Dali::Actor *argp2 ;
61198
61199   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61200   argp2 = (Dali::Actor *)jarg2;
61201   if (!argp2) {
61202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61203     return ;
61204   }
61205   arg2 = *argp2;
61206   {
61207     try {
61208       (arg1)->SetSelectedImage(arg2);
61209     } catch (std::out_of_range& e) {
61210       {
61211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61212       };
61213     } catch (std::exception& e) {
61214       {
61215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61216       };
61217     } catch (...) {
61218       {
61219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61220       };
61221     }
61222   }
61223 }
61224
61225
61226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
61227   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61228   Dali::Actor arg2 ;
61229   Dali::Actor *argp2 ;
61230
61231   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61232   argp2 = (Dali::Actor *)jarg2;
61233   if (!argp2) {
61234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61235     return ;
61236   }
61237   arg2 = *argp2;
61238   {
61239     try {
61240       (arg1)->SetSelectedBackgroundImage(arg2);
61241     } catch (std::out_of_range& e) {
61242       {
61243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61244       };
61245     } catch (std::exception& e) {
61246       {
61247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61248       };
61249     } catch (...) {
61250       {
61251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61252       };
61253     }
61254   }
61255 }
61256
61257
61258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
61259   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61260   Dali::Actor arg2 ;
61261   Dali::Actor *argp2 ;
61262
61263   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61264   argp2 = (Dali::Actor *)jarg2;
61265   if (!argp2) {
61266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61267     return ;
61268   }
61269   arg2 = *argp2;
61270   {
61271     try {
61272       (arg1)->SetDisabledBackgroundImage(arg2);
61273     } catch (std::out_of_range& e) {
61274       {
61275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61276       };
61277     } catch (std::exception& e) {
61278       {
61279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61280       };
61281     } catch (...) {
61282       {
61283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61284       };
61285     }
61286   }
61287 }
61288
61289
61290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
61291   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61292   Dali::Actor arg2 ;
61293   Dali::Actor *argp2 ;
61294
61295   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61296   argp2 = (Dali::Actor *)jarg2;
61297   if (!argp2) {
61298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61299     return ;
61300   }
61301   arg2 = *argp2;
61302   {
61303     try {
61304       (arg1)->SetDisabledImage(arg2);
61305     } catch (std::out_of_range& e) {
61306       {
61307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61308       };
61309     } catch (std::exception& e) {
61310       {
61311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61312       };
61313     } catch (...) {
61314       {
61315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61316       };
61317     }
61318   }
61319 }
61320
61321
61322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
61323   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61324   Dali::Actor arg2 ;
61325   Dali::Actor *argp2 ;
61326
61327   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61328   argp2 = (Dali::Actor *)jarg2;
61329   if (!argp2) {
61330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61331     return ;
61332   }
61333   arg2 = *argp2;
61334   {
61335     try {
61336       (arg1)->SetDisabledSelectedImage(arg2);
61337     } catch (std::out_of_range& e) {
61338       {
61339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61340       };
61341     } catch (std::exception& e) {
61342       {
61343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61344       };
61345     } catch (...) {
61346       {
61347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61348       };
61349     }
61350   }
61351 }
61352
61353
61354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
61355   void * jresult ;
61356   Dali::Toolkit::RadioButton *result = 0 ;
61357
61358   {
61359     try {
61360       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
61361     } catch (std::out_of_range& e) {
61362       {
61363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61364       };
61365     } catch (std::exception& e) {
61366       {
61367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61368       };
61369     } catch (...) {
61370       {
61371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61372       };
61373     }
61374   }
61375   jresult = (void *)result;
61376   return jresult;
61377 }
61378
61379
61380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
61381   void * jresult ;
61382   Dali::Toolkit::RadioButton *arg1 = 0 ;
61383   Dali::Toolkit::RadioButton *result = 0 ;
61384
61385   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61386   if (!arg1) {
61387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61388     return 0;
61389   }
61390   {
61391     try {
61392       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
61393     } catch (std::out_of_range& e) {
61394       {
61395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61396       };
61397     } catch (std::exception& e) {
61398       {
61399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61400       };
61401     } catch (...) {
61402       {
61403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61404       };
61405     }
61406   }
61407   jresult = (void *)result;
61408   return jresult;
61409 }
61410
61411
61412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
61413   void * jresult ;
61414   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61415   Dali::Toolkit::RadioButton *arg2 = 0 ;
61416   Dali::Toolkit::RadioButton *result = 0 ;
61417
61418   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61419   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
61420   if (!arg2) {
61421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61422     return 0;
61423   }
61424   {
61425     try {
61426       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
61427     } catch (std::out_of_range& e) {
61428       {
61429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61430       };
61431     } catch (std::exception& e) {
61432       {
61433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61434       };
61435     } catch (...) {
61436       {
61437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61438       };
61439     }
61440   }
61441   jresult = (void *)result;
61442   return jresult;
61443 }
61444
61445
61446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
61447   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61448
61449   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61450   {
61451     try {
61452       delete arg1;
61453     } catch (std::out_of_range& e) {
61454       {
61455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61456       };
61457     } catch (std::exception& e) {
61458       {
61459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61460       };
61461     } catch (...) {
61462       {
61463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61464       };
61465     }
61466   }
61467 }
61468
61469
61470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
61471   void * jresult ;
61472   Dali::Toolkit::RadioButton result;
61473
61474   {
61475     try {
61476       result = Dali::Toolkit::RadioButton::New();
61477     } catch (std::out_of_range& e) {
61478       {
61479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61480       };
61481     } catch (std::exception& e) {
61482       {
61483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61484       };
61485     } catch (...) {
61486       {
61487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61488       };
61489     }
61490   }
61491   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61492   return jresult;
61493 }
61494
61495
61496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
61497   void * jresult ;
61498   std::string *arg1 = 0 ;
61499   Dali::Toolkit::RadioButton result;
61500
61501   if (!jarg1) {
61502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61503     return 0;
61504   }
61505   std::string arg1_str(jarg1);
61506   arg1 = &arg1_str;
61507   {
61508     try {
61509       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
61510     } catch (std::out_of_range& e) {
61511       {
61512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61513       };
61514     } catch (std::exception& e) {
61515       {
61516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61517       };
61518     } catch (...) {
61519       {
61520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61521       };
61522     }
61523   }
61524   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61525
61526   //argout typemap for const std::string&
61527
61528   return jresult;
61529 }
61530
61531
61532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
61533   void * jresult ;
61534   Dali::BaseHandle arg1 ;
61535   Dali::BaseHandle *argp1 ;
61536   Dali::Toolkit::RadioButton result;
61537
61538   argp1 = (Dali::BaseHandle *)jarg1;
61539   if (!argp1) {
61540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61541     return 0;
61542   }
61543   arg1 = *argp1;
61544   {
61545     try {
61546       result = Dali::Toolkit::RadioButton::DownCast(arg1);
61547     } catch (std::out_of_range& e) {
61548       {
61549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61550       };
61551     } catch (std::exception& e) {
61552       {
61553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61554       };
61555     } catch (...) {
61556       {
61557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61558       };
61559     }
61560   }
61561   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61562   return jresult;
61563 }
61564
61565
61566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
61567   int jresult ;
61568   int result;
61569
61570   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
61571   jresult = (int)result;
61572   return jresult;
61573 }
61574
61575
61576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
61577   int jresult ;
61578   int result;
61579
61580   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
61581   jresult = (int)result;
61582   return jresult;
61583 }
61584
61585
61586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
61587   int jresult ;
61588   int result;
61589
61590   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
61591   jresult = (int)result;
61592   return jresult;
61593 }
61594
61595
61596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
61597   int jresult ;
61598   int result;
61599
61600   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
61601   jresult = (int)result;
61602   return jresult;
61603 }
61604
61605
61606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
61607   int jresult ;
61608   int result;
61609
61610   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
61611   jresult = (int)result;
61612   return jresult;
61613 }
61614
61615
61616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
61617   int jresult ;
61618   int result;
61619
61620   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
61621   jresult = (int)result;
61622   return jresult;
61623 }
61624
61625
61626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
61627   void * jresult ;
61628   Dali::Toolkit::FlexContainer::Property *result = 0 ;
61629
61630   {
61631     try {
61632       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
61633     } catch (std::out_of_range& e) {
61634       {
61635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61636       };
61637     } catch (std::exception& e) {
61638       {
61639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61640       };
61641     } catch (...) {
61642       {
61643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61644       };
61645     }
61646   }
61647   jresult = (void *)result;
61648   return jresult;
61649 }
61650
61651
61652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
61653   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
61654
61655   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
61656   {
61657     try {
61658       delete arg1;
61659     } catch (std::out_of_range& e) {
61660       {
61661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61662       };
61663     } catch (std::exception& e) {
61664       {
61665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61666       };
61667     } catch (...) {
61668       {
61669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61670       };
61671     }
61672   }
61673 }
61674
61675
61676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
61677   int jresult ;
61678   int result;
61679
61680   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
61681   jresult = (int)result;
61682   return jresult;
61683 }
61684
61685
61686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
61687   int jresult ;
61688   int result;
61689
61690   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
61691   jresult = (int)result;
61692   return jresult;
61693 }
61694
61695
61696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
61697   int jresult ;
61698   int result;
61699
61700   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
61701   jresult = (int)result;
61702   return jresult;
61703 }
61704
61705
61706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
61707   void * jresult ;
61708   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
61709
61710   {
61711     try {
61712       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
61713     } catch (std::out_of_range& e) {
61714       {
61715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61716       };
61717     } catch (std::exception& e) {
61718       {
61719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61720       };
61721     } catch (...) {
61722       {
61723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61724       };
61725     }
61726   }
61727   jresult = (void *)result;
61728   return jresult;
61729 }
61730
61731
61732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
61733   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
61734
61735   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
61736   {
61737     try {
61738       delete arg1;
61739     } catch (std::out_of_range& e) {
61740       {
61741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61742       };
61743     } catch (std::exception& e) {
61744       {
61745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61746       };
61747     } catch (...) {
61748       {
61749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61750       };
61751     }
61752   }
61753 }
61754
61755
61756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
61757   void * jresult ;
61758   Dali::Toolkit::FlexContainer *result = 0 ;
61759
61760   {
61761     try {
61762       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
61763     } catch (std::out_of_range& e) {
61764       {
61765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61766       };
61767     } catch (std::exception& e) {
61768       {
61769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61770       };
61771     } catch (...) {
61772       {
61773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61774       };
61775     }
61776   }
61777   jresult = (void *)result;
61778   return jresult;
61779 }
61780
61781
61782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
61783   void * jresult ;
61784   Dali::Toolkit::FlexContainer *arg1 = 0 ;
61785   Dali::Toolkit::FlexContainer *result = 0 ;
61786
61787   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61788   if (!arg1) {
61789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61790     return 0;
61791   }
61792   {
61793     try {
61794       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
61795     } catch (std::out_of_range& e) {
61796       {
61797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61798       };
61799     } catch (std::exception& e) {
61800       {
61801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61802       };
61803     } catch (...) {
61804       {
61805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61806       };
61807     }
61808   }
61809   jresult = (void *)result;
61810   return jresult;
61811 }
61812
61813
61814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
61815   void * jresult ;
61816   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61817   Dali::Toolkit::FlexContainer *arg2 = 0 ;
61818   Dali::Toolkit::FlexContainer *result = 0 ;
61819
61820   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61821   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
61822   if (!arg2) {
61823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61824     return 0;
61825   }
61826   {
61827     try {
61828       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
61829     } catch (std::out_of_range& e) {
61830       {
61831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61832       };
61833     } catch (std::exception& e) {
61834       {
61835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61836       };
61837     } catch (...) {
61838       {
61839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61840       };
61841     }
61842   }
61843   jresult = (void *)result;
61844   return jresult;
61845 }
61846
61847
61848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
61849   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61850
61851   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61852   {
61853     try {
61854       delete arg1;
61855     } catch (std::out_of_range& e) {
61856       {
61857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61858       };
61859     } catch (std::exception& e) {
61860       {
61861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61862       };
61863     } catch (...) {
61864       {
61865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61866       };
61867     }
61868   }
61869 }
61870
61871
61872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
61873   void * jresult ;
61874   Dali::Toolkit::FlexContainer result;
61875
61876   {
61877     try {
61878       result = Dali::Toolkit::FlexContainer::New();
61879     } catch (std::out_of_range& e) {
61880       {
61881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61882       };
61883     } catch (std::exception& e) {
61884       {
61885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61886       };
61887     } catch (...) {
61888       {
61889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61890       };
61891     }
61892   }
61893   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61894   return jresult;
61895 }
61896
61897
61898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
61899   void * jresult ;
61900   Dali::BaseHandle arg1 ;
61901   Dali::BaseHandle *argp1 ;
61902   Dali::Toolkit::FlexContainer result;
61903
61904   argp1 = (Dali::BaseHandle *)jarg1;
61905   if (!argp1) {
61906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61907     return 0;
61908   }
61909   arg1 = *argp1;
61910   {
61911     try {
61912       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
61913     } catch (std::out_of_range& e) {
61914       {
61915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61916       };
61917     } catch (std::exception& e) {
61918       {
61919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61920       };
61921     } catch (...) {
61922       {
61923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61924       };
61925     }
61926   }
61927   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
61928   return jresult;
61929 }
61930
61931
61932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
61933   int jresult ;
61934   int result;
61935
61936   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
61937   jresult = (int)result;
61938   return jresult;
61939 }
61940
61941
61942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
61943   int jresult ;
61944   int result;
61945
61946   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
61947   jresult = (int)result;
61948   return jresult;
61949 }
61950
61951
61952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
61953   int jresult ;
61954   int result;
61955
61956   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
61957   jresult = (int)result;
61958   return jresult;
61959 }
61960
61961
61962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
61963   int jresult ;
61964   int result;
61965
61966   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
61967   jresult = (int)result;
61968   return jresult;
61969 }
61970
61971
61972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
61973   void * jresult ;
61974   Dali::Toolkit::ImageView::Property *result = 0 ;
61975
61976   {
61977     try {
61978       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
61979     } catch (std::out_of_range& e) {
61980       {
61981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61982       };
61983     } catch (std::exception& e) {
61984       {
61985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61986       };
61987     } catch (...) {
61988       {
61989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61990       };
61991     }
61992   }
61993   jresult = (void *)result;
61994   return jresult;
61995 }
61996
61997
61998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
61999   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
62000
62001   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
62002   {
62003     try {
62004       delete arg1;
62005     } catch (std::out_of_range& e) {
62006       {
62007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62008       };
62009     } catch (std::exception& e) {
62010       {
62011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62012       };
62013     } catch (...) {
62014       {
62015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62016       };
62017     }
62018   }
62019 }
62020
62021
62022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
62023   void * jresult ;
62024   Dali::Toolkit::ImageView *result = 0 ;
62025
62026   {
62027     try {
62028       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
62029     } catch (std::out_of_range& e) {
62030       {
62031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62032       };
62033     } catch (std::exception& e) {
62034       {
62035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62036       };
62037     } catch (...) {
62038       {
62039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62040       };
62041     }
62042   }
62043   jresult = (void *)result;
62044   return jresult;
62045 }
62046
62047
62048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
62049   void * jresult ;
62050   Dali::Toolkit::ImageView result;
62051
62052   {
62053     try {
62054       result = Dali::Toolkit::ImageView::New();
62055     } catch (std::out_of_range& e) {
62056       {
62057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62058       };
62059     } catch (std::exception& e) {
62060       {
62061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62062       };
62063     } catch (...) {
62064       {
62065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62066       };
62067     }
62068   }
62069   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62070   return jresult;
62071 }
62072
62073
62074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
62075   void * jresult ;
62076   Dali::Image arg1 ;
62077   Dali::Image *argp1 ;
62078   Dali::Toolkit::ImageView result;
62079
62080   argp1 = (Dali::Image *)jarg1;
62081   if (!argp1) {
62082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62083     return 0;
62084   }
62085   arg1 = *argp1;
62086   {
62087     try {
62088       result = Dali::Toolkit::ImageView::New(arg1);
62089     } catch (std::out_of_range& e) {
62090       {
62091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62092       };
62093     } catch (std::exception& e) {
62094       {
62095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62096       };
62097     } catch (...) {
62098       {
62099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62100       };
62101     }
62102   }
62103   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62104   return jresult;
62105 }
62106
62107
62108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
62109   void * jresult ;
62110   std::string *arg1 = 0 ;
62111   Dali::Toolkit::ImageView result;
62112
62113   if (!jarg1) {
62114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62115     return 0;
62116   }
62117   std::string arg1_str(jarg1);
62118   arg1 = &arg1_str;
62119   {
62120     try {
62121       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
62122     } catch (std::out_of_range& e) {
62123       {
62124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62125       };
62126     } catch (std::exception& e) {
62127       {
62128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62129       };
62130     } catch (...) {
62131       {
62132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62133       };
62134     }
62135   }
62136   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62137
62138   //argout typemap for const std::string&
62139
62140   return jresult;
62141 }
62142
62143
62144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
62145   void * jresult ;
62146   std::string *arg1 = 0 ;
62147   Dali::ImageDimensions arg2 ;
62148   Dali::ImageDimensions *argp2 ;
62149   Dali::Toolkit::ImageView result;
62150
62151   if (!jarg1) {
62152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62153     return 0;
62154   }
62155   std::string arg1_str(jarg1);
62156   arg1 = &arg1_str;
62157   argp2 = (Dali::ImageDimensions *)jarg2;
62158   if (!argp2) {
62159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62160     return 0;
62161   }
62162   arg2 = *argp2;
62163   {
62164     try {
62165       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
62166     } catch (std::out_of_range& e) {
62167       {
62168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62169       };
62170     } catch (std::exception& e) {
62171       {
62172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62173       };
62174     } catch (...) {
62175       {
62176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62177       };
62178     }
62179   }
62180   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62181
62182   //argout typemap for const std::string&
62183
62184   return jresult;
62185 }
62186
62187
62188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
62189   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62190
62191   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62192   {
62193     try {
62194       delete arg1;
62195     } catch (std::out_of_range& e) {
62196       {
62197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62198       };
62199     } catch (std::exception& e) {
62200       {
62201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62202       };
62203     } catch (...) {
62204       {
62205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62206       };
62207     }
62208   }
62209 }
62210
62211
62212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
62213   void * jresult ;
62214   Dali::Toolkit::ImageView *arg1 = 0 ;
62215   Dali::Toolkit::ImageView *result = 0 ;
62216
62217   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62218   if (!arg1) {
62219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62220     return 0;
62221   }
62222   {
62223     try {
62224       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
62225     } catch (std::out_of_range& e) {
62226       {
62227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62228       };
62229     } catch (std::exception& e) {
62230       {
62231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62232       };
62233     } catch (...) {
62234       {
62235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62236       };
62237     }
62238   }
62239   jresult = (void *)result;
62240   return jresult;
62241 }
62242
62243
62244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
62245   void * jresult ;
62246   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62247   Dali::Toolkit::ImageView *arg2 = 0 ;
62248   Dali::Toolkit::ImageView *result = 0 ;
62249
62250   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62251   arg2 = (Dali::Toolkit::ImageView *)jarg2;
62252   if (!arg2) {
62253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62254     return 0;
62255   }
62256   {
62257     try {
62258       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
62259     } catch (std::out_of_range& e) {
62260       {
62261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62262       };
62263     } catch (std::exception& e) {
62264       {
62265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62266       };
62267     } catch (...) {
62268       {
62269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62270       };
62271     }
62272   }
62273   jresult = (void *)result;
62274   return jresult;
62275 }
62276
62277
62278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
62279   void * jresult ;
62280   Dali::BaseHandle arg1 ;
62281   Dali::BaseHandle *argp1 ;
62282   Dali::Toolkit::ImageView result;
62283
62284   argp1 = (Dali::BaseHandle *)jarg1;
62285   if (!argp1) {
62286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62287     return 0;
62288   }
62289   arg1 = *argp1;
62290   {
62291     try {
62292       result = Dali::Toolkit::ImageView::DownCast(arg1);
62293     } catch (std::out_of_range& e) {
62294       {
62295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62296       };
62297     } catch (std::exception& e) {
62298       {
62299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62300       };
62301     } catch (...) {
62302       {
62303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62304       };
62305     }
62306   }
62307   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62308   return jresult;
62309 }
62310
62311
62312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
62313   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62314   Dali::Image arg2 ;
62315   Dali::Image *argp2 ;
62316
62317   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62318   argp2 = (Dali::Image *)jarg2;
62319   if (!argp2) {
62320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62321     return ;
62322   }
62323   arg2 = *argp2;
62324   {
62325     try {
62326       (arg1)->SetImage(arg2);
62327     } catch (std::out_of_range& e) {
62328       {
62329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62330       };
62331     } catch (std::exception& e) {
62332       {
62333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62334       };
62335     } catch (...) {
62336       {
62337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62338       };
62339     }
62340   }
62341 }
62342
62343
62344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
62345   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62346   std::string *arg2 = 0 ;
62347
62348   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62349   if (!jarg2) {
62350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62351     return ;
62352   }
62353   std::string arg2_str(jarg2);
62354   arg2 = &arg2_str;
62355   {
62356     try {
62357       (arg1)->SetImage((std::string const &)*arg2);
62358     } catch (std::out_of_range& e) {
62359       {
62360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62361       };
62362     } catch (std::exception& e) {
62363       {
62364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62365       };
62366     } catch (...) {
62367       {
62368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62369       };
62370     }
62371   }
62372
62373   //argout typemap for const std::string&
62374
62375 }
62376
62377
62378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62379   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62380   std::string *arg2 = 0 ;
62381   Dali::ImageDimensions arg3 ;
62382   Dali::ImageDimensions *argp3 ;
62383
62384   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62385   if (!jarg2) {
62386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62387     return ;
62388   }
62389   std::string arg2_str(jarg2);
62390   arg2 = &arg2_str;
62391   argp3 = (Dali::ImageDimensions *)jarg3;
62392   if (!argp3) {
62393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62394     return ;
62395   }
62396   arg3 = *argp3;
62397   {
62398     try {
62399       (arg1)->SetImage((std::string const &)*arg2,arg3);
62400     } catch (std::out_of_range& e) {
62401       {
62402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62403       };
62404     } catch (std::exception& e) {
62405       {
62406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62407       };
62408     } catch (...) {
62409       {
62410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62411       };
62412     }
62413   }
62414
62415   //argout typemap for const std::string&
62416
62417 }
62418
62419
62420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
62421   void * jresult ;
62422   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62423   Dali::Image result;
62424
62425   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62426   {
62427     try {
62428       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
62429     } catch (std::out_of_range& e) {
62430       {
62431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62432       };
62433     } catch (std::exception& e) {
62434       {
62435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62436       };
62437     } catch (...) {
62438       {
62439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62440       };
62441     }
62442   }
62443   jresult = new Dali::Image((const Dali::Image &)result);
62444   return jresult;
62445 }
62446
62447
62448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
62449   int jresult ;
62450   int result;
62451
62452   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
62453   jresult = (int)result;
62454   return jresult;
62455 }
62456
62457
62458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
62459   int jresult ;
62460   int result;
62461
62462   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
62463   jresult = (int)result;
62464   return jresult;
62465 }
62466
62467
62468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
62469   int jresult ;
62470   int result;
62471
62472   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
62473   jresult = (int)result;
62474   return jresult;
62475 }
62476
62477
62478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
62479   int jresult ;
62480   int result;
62481
62482   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
62483   jresult = (int)result;
62484   return jresult;
62485 }
62486
62487
62488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
62489   int jresult ;
62490   int result;
62491
62492   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
62493   jresult = (int)result;
62494   return jresult;
62495 }
62496
62497
62498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
62499   int jresult ;
62500   int result;
62501
62502   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
62503   jresult = (int)result;
62504   return jresult;
62505 }
62506
62507
62508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
62509   int jresult ;
62510   int result;
62511
62512   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
62513   jresult = (int)result;
62514   return jresult;
62515 }
62516
62517
62518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
62519   int jresult ;
62520   int result;
62521
62522   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
62523   jresult = (int)result;
62524   return jresult;
62525 }
62526
62527
62528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
62529   void * jresult ;
62530   Dali::Toolkit::Model3dView::Property *result = 0 ;
62531
62532   {
62533     try {
62534       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
62535     } catch (std::out_of_range& e) {
62536       {
62537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62538       };
62539     } catch (std::exception& e) {
62540       {
62541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62542       };
62543     } catch (...) {
62544       {
62545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62546       };
62547     }
62548   }
62549   jresult = (void *)result;
62550   return jresult;
62551 }
62552
62553
62554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
62555   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
62556
62557   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
62558   {
62559     try {
62560       delete arg1;
62561     } catch (std::out_of_range& e) {
62562       {
62563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62564       };
62565     } catch (std::exception& e) {
62566       {
62567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62568       };
62569     } catch (...) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62572       };
62573     }
62574   }
62575 }
62576
62577
62578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
62579   void * jresult ;
62580   Dali::Toolkit::Model3dView result;
62581
62582   {
62583     try {
62584       result = Dali::Toolkit::Model3dView::New();
62585     } catch (std::out_of_range& e) {
62586       {
62587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62588       };
62589     } catch (std::exception& e) {
62590       {
62591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62592       };
62593     } catch (...) {
62594       {
62595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62596       };
62597     }
62598   }
62599   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62600   return jresult;
62601 }
62602
62603
62604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
62605   void * jresult ;
62606   std::string *arg1 = 0 ;
62607   std::string *arg2 = 0 ;
62608   std::string *arg3 = 0 ;
62609   Dali::Toolkit::Model3dView result;
62610
62611   if (!jarg1) {
62612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62613     return 0;
62614   }
62615   std::string arg1_str(jarg1);
62616   arg1 = &arg1_str;
62617   if (!jarg2) {
62618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62619     return 0;
62620   }
62621   std::string arg2_str(jarg2);
62622   arg2 = &arg2_str;
62623   if (!jarg3) {
62624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62625     return 0;
62626   }
62627   std::string arg3_str(jarg3);
62628   arg3 = &arg3_str;
62629   {
62630     try {
62631       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
62632     } catch (std::out_of_range& e) {
62633       {
62634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62635       };
62636     } catch (std::exception& e) {
62637       {
62638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62639       };
62640     } catch (...) {
62641       {
62642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62643       };
62644     }
62645   }
62646   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62647
62648   //argout typemap for const std::string&
62649
62650
62651   //argout typemap for const std::string&
62652
62653
62654   //argout typemap for const std::string&
62655
62656   return jresult;
62657 }
62658
62659
62660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
62661   void * jresult ;
62662   Dali::Toolkit::Model3dView *result = 0 ;
62663
62664   {
62665     try {
62666       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
62667     } catch (std::out_of_range& e) {
62668       {
62669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62670       };
62671     } catch (std::exception& e) {
62672       {
62673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62674       };
62675     } catch (...) {
62676       {
62677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62678       };
62679     }
62680   }
62681   jresult = (void *)result;
62682   return jresult;
62683 }
62684
62685
62686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
62687   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62688
62689   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62690   {
62691     try {
62692       delete arg1;
62693     } catch (std::out_of_range& e) {
62694       {
62695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62696       };
62697     } catch (std::exception& e) {
62698       {
62699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62700       };
62701     } catch (...) {
62702       {
62703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62704       };
62705     }
62706   }
62707 }
62708
62709
62710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
62711   void * jresult ;
62712   Dali::Toolkit::Model3dView *arg1 = 0 ;
62713   Dali::Toolkit::Model3dView *result = 0 ;
62714
62715   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62716   if (!arg1) {
62717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62718     return 0;
62719   }
62720   {
62721     try {
62722       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
62723     } catch (std::out_of_range& e) {
62724       {
62725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62726       };
62727     } catch (std::exception& e) {
62728       {
62729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62730       };
62731     } catch (...) {
62732       {
62733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62734       };
62735     }
62736   }
62737   jresult = (void *)result;
62738   return jresult;
62739 }
62740
62741
62742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
62743   void * jresult ;
62744   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62745   Dali::Toolkit::Model3dView *arg2 = 0 ;
62746   Dali::Toolkit::Model3dView *result = 0 ;
62747
62748   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62749   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
62750   if (!arg2) {
62751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62752     return 0;
62753   }
62754   {
62755     try {
62756       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
62757     } catch (std::out_of_range& e) {
62758       {
62759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62760       };
62761     } catch (std::exception& e) {
62762       {
62763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62764       };
62765     } catch (...) {
62766       {
62767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62768       };
62769     }
62770   }
62771   jresult = (void *)result;
62772   return jresult;
62773 }
62774
62775
62776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
62777   void * jresult ;
62778   Dali::BaseHandle arg1 ;
62779   Dali::BaseHandle *argp1 ;
62780   Dali::Toolkit::Model3dView result;
62781
62782   argp1 = (Dali::BaseHandle *)jarg1;
62783   if (!argp1) {
62784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62785     return 0;
62786   }
62787   arg1 = *argp1;
62788   {
62789     try {
62790       result = Dali::Toolkit::Model3dView::DownCast(arg1);
62791     } catch (std::out_of_range& e) {
62792       {
62793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62794       };
62795     } catch (std::exception& e) {
62796       {
62797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62798       };
62799     } catch (...) {
62800       {
62801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62802       };
62803     }
62804   }
62805   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62806   return jresult;
62807 }
62808
62809
62810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
62811   int jresult ;
62812   int result;
62813
62814   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
62815   jresult = (int)result;
62816   return jresult;
62817 }
62818
62819
62820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
62821   int jresult ;
62822   int result;
62823
62824   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
62825   jresult = (int)result;
62826   return jresult;
62827 }
62828
62829
62830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
62831   int jresult ;
62832   int result;
62833
62834   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
62835   jresult = (int)result;
62836   return jresult;
62837 }
62838
62839
62840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
62841   int jresult ;
62842   int result;
62843
62844   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
62845   jresult = (int)result;
62846   return jresult;
62847 }
62848
62849
62850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
62851   int jresult ;
62852   int result;
62853
62854   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
62855   jresult = (int)result;
62856   return jresult;
62857 }
62858
62859
62860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
62861   int jresult ;
62862   int result;
62863
62864   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
62865   jresult = (int)result;
62866   return jresult;
62867 }
62868
62869
62870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
62871   int jresult ;
62872   int result;
62873
62874   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
62875   jresult = (int)result;
62876   return jresult;
62877 }
62878
62879
62880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
62881   int jresult ;
62882   int result;
62883
62884   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
62885   jresult = (int)result;
62886   return jresult;
62887 }
62888
62889
62890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
62891   int jresult ;
62892   int result;
62893
62894   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
62895   jresult = (int)result;
62896   return jresult;
62897 }
62898
62899
62900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
62901   void * jresult ;
62902   Dali::Toolkit::ScrollBar::Property *result = 0 ;
62903
62904   {
62905     try {
62906       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
62907     } catch (std::out_of_range& e) {
62908       {
62909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62910       };
62911     } catch (std::exception& e) {
62912       {
62913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62914       };
62915     } catch (...) {
62916       {
62917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62918       };
62919     }
62920   }
62921   jresult = (void *)result;
62922   return jresult;
62923 }
62924
62925
62926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
62927   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
62928
62929   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
62930   {
62931     try {
62932       delete arg1;
62933     } catch (std::out_of_range& e) {
62934       {
62935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62936       };
62937     } catch (std::exception& e) {
62938       {
62939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62940       };
62941     } catch (...) {
62942       {
62943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62944       };
62945     }
62946   }
62947 }
62948
62949
62950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
62951   void * jresult ;
62952   Dali::Toolkit::ScrollBar *result = 0 ;
62953
62954   {
62955     try {
62956       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
62957     } catch (std::out_of_range& e) {
62958       {
62959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62960       };
62961     } catch (std::exception& e) {
62962       {
62963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62964       };
62965     } catch (...) {
62966       {
62967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62968       };
62969     }
62970   }
62971   jresult = (void *)result;
62972   return jresult;
62973 }
62974
62975
62976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
62977   void * jresult ;
62978   Dali::Toolkit::ScrollBar *arg1 = 0 ;
62979   Dali::Toolkit::ScrollBar *result = 0 ;
62980
62981   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
62982   if (!arg1) {
62983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
62984     return 0;
62985   }
62986   {
62987     try {
62988       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
62989     } catch (std::out_of_range& e) {
62990       {
62991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62992       };
62993     } catch (std::exception& e) {
62994       {
62995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62996       };
62997     } catch (...) {
62998       {
62999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63000       };
63001     }
63002   }
63003   jresult = (void *)result;
63004   return jresult;
63005 }
63006
63007
63008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
63009   void * jresult ;
63010   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63011   Dali::Toolkit::ScrollBar *arg2 = 0 ;
63012   Dali::Toolkit::ScrollBar *result = 0 ;
63013
63014   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63015   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
63016   if (!arg2) {
63017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
63018     return 0;
63019   }
63020   {
63021     try {
63022       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
63023     } catch (std::out_of_range& e) {
63024       {
63025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63026       };
63027     } catch (std::exception& e) {
63028       {
63029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63030       };
63031     } catch (...) {
63032       {
63033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63034       };
63035     }
63036   }
63037   jresult = (void *)result;
63038   return jresult;
63039 }
63040
63041
63042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
63043   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63044
63045   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63046   {
63047     try {
63048       delete arg1;
63049     } catch (std::out_of_range& e) {
63050       {
63051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63052       };
63053     } catch (std::exception& e) {
63054       {
63055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63056       };
63057     } catch (...) {
63058       {
63059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63060       };
63061     }
63062   }
63063 }
63064
63065
63066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
63067   void * jresult ;
63068   Dali::Toolkit::ScrollBar::Direction arg1 ;
63069   Dali::Toolkit::ScrollBar result;
63070
63071   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
63072   {
63073     try {
63074       result = Dali::Toolkit::ScrollBar::New(arg1);
63075     } catch (std::out_of_range& e) {
63076       {
63077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63078       };
63079     } catch (std::exception& e) {
63080       {
63081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63082       };
63083     } catch (...) {
63084       {
63085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63086       };
63087     }
63088   }
63089   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63090   return jresult;
63091 }
63092
63093
63094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
63095   void * jresult ;
63096   Dali::Toolkit::ScrollBar result;
63097
63098   {
63099     try {
63100       result = Dali::Toolkit::ScrollBar::New();
63101     } catch (std::out_of_range& e) {
63102       {
63103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63104       };
63105     } catch (std::exception& e) {
63106       {
63107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63108       };
63109     } catch (...) {
63110       {
63111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63112       };
63113     }
63114   }
63115   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63116   return jresult;
63117 }
63118
63119
63120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
63121   void * jresult ;
63122   Dali::BaseHandle arg1 ;
63123   Dali::BaseHandle *argp1 ;
63124   Dali::Toolkit::ScrollBar result;
63125
63126   argp1 = (Dali::BaseHandle *)jarg1;
63127   if (!argp1) {
63128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63129     return 0;
63130   }
63131   arg1 = *argp1;
63132   {
63133     try {
63134       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
63135     } catch (std::out_of_range& e) {
63136       {
63137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63138       };
63139     } catch (std::exception& e) {
63140       {
63141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63142       };
63143     } catch (...) {
63144       {
63145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63146       };
63147     }
63148   }
63149   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63150   return jresult;
63151 }
63152
63153
63154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
63155   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63156   Dali::Handle arg2 ;
63157   Dali::Property::Index arg3 ;
63158   Dali::Property::Index arg4 ;
63159   Dali::Property::Index arg5 ;
63160   Dali::Property::Index arg6 ;
63161   Dali::Handle *argp2 ;
63162
63163   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63164   argp2 = (Dali::Handle *)jarg2;
63165   if (!argp2) {
63166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
63167     return ;
63168   }
63169   arg2 = *argp2;
63170   arg3 = (Dali::Property::Index)jarg3;
63171   arg4 = (Dali::Property::Index)jarg4;
63172   arg5 = (Dali::Property::Index)jarg5;
63173   arg6 = (Dali::Property::Index)jarg6;
63174   {
63175     try {
63176       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
63177     } catch (std::out_of_range& e) {
63178       {
63179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63180       };
63181     } catch (std::exception& e) {
63182       {
63183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63184       };
63185     } catch (...) {
63186       {
63187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63188       };
63189     }
63190   }
63191 }
63192
63193
63194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
63195   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63196   Dali::Actor arg2 ;
63197   Dali::Actor *argp2 ;
63198
63199   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63200   argp2 = (Dali::Actor *)jarg2;
63201   if (!argp2) {
63202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63203     return ;
63204   }
63205   arg2 = *argp2;
63206   {
63207     try {
63208       (arg1)->SetScrollIndicator(arg2);
63209     } catch (std::out_of_range& e) {
63210       {
63211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63212       };
63213     } catch (std::exception& e) {
63214       {
63215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63216       };
63217     } catch (...) {
63218       {
63219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63220       };
63221     }
63222   }
63223 }
63224
63225
63226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
63227   void * jresult ;
63228   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63229   Dali::Actor result;
63230
63231   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63232   {
63233     try {
63234       result = (arg1)->GetScrollIndicator();
63235     } catch (std::out_of_range& e) {
63236       {
63237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63238       };
63239     } catch (std::exception& e) {
63240       {
63241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63242       };
63243     } catch (...) {
63244       {
63245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63246       };
63247     }
63248   }
63249   jresult = new Dali::Actor((const Dali::Actor &)result);
63250   return jresult;
63251 }
63252
63253
63254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
63255   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63256   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
63257
63258   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63259   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
63260   if (!arg2) {
63261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
63262     return ;
63263   }
63264   {
63265     try {
63266       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
63267     } catch (std::out_of_range& e) {
63268       {
63269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63270       };
63271     } catch (std::exception& e) {
63272       {
63273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63274       };
63275     } catch (...) {
63276       {
63277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63278       };
63279     }
63280   }
63281 }
63282
63283
63284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
63285   void * jresult ;
63286   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63287   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
63288
63289   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63290   {
63291     try {
63292       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
63293     } catch (std::out_of_range& e) {
63294       {
63295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63296       };
63297     } catch (std::exception& e) {
63298       {
63299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63300       };
63301     } catch (...) {
63302       {
63303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63304       };
63305     }
63306   }
63307   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
63308   return jresult;
63309 }
63310
63311
63312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
63313   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63314   Dali::Toolkit::ScrollBar::Direction arg2 ;
63315
63316   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63317   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
63318   {
63319     try {
63320       (arg1)->SetScrollDirection(arg2);
63321     } catch (std::out_of_range& e) {
63322       {
63323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63324       };
63325     } catch (std::exception& e) {
63326       {
63327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63328       };
63329     } catch (...) {
63330       {
63331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63332       };
63333     }
63334   }
63335 }
63336
63337
63338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
63339   int jresult ;
63340   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63341   Dali::Toolkit::ScrollBar::Direction result;
63342
63343   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63344   {
63345     try {
63346       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
63347     } catch (std::out_of_range& e) {
63348       {
63349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63350       };
63351     } catch (std::exception& e) {
63352       {
63353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63354       };
63355     } catch (...) {
63356       {
63357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63358       };
63359     }
63360   }
63361   jresult = (int)result;
63362   return jresult;
63363 }
63364
63365
63366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
63367   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63368   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
63369
63370   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63371   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
63372   {
63373     try {
63374       (arg1)->SetIndicatorHeightPolicy(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 int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
63393   int jresult ;
63394   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63395   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
63396
63397   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63398   {
63399     try {
63400       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
63401     } catch (std::out_of_range& e) {
63402       {
63403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63404       };
63405     } catch (std::exception& e) {
63406       {
63407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63408       };
63409     } catch (...) {
63410       {
63411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63412       };
63413     }
63414   }
63415   jresult = (int)result;
63416   return jresult;
63417 }
63418
63419
63420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
63421   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63422   float arg2 ;
63423
63424   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63425   arg2 = (float)jarg2;
63426   {
63427     try {
63428       (arg1)->SetIndicatorFixedHeight(arg2);
63429     } catch (std::out_of_range& e) {
63430       {
63431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63432       };
63433     } catch (std::exception& e) {
63434       {
63435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63436       };
63437     } catch (...) {
63438       {
63439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63440       };
63441     }
63442   }
63443 }
63444
63445
63446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
63447   float jresult ;
63448   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63449   float result;
63450
63451   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63452   {
63453     try {
63454       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
63455     } catch (std::out_of_range& e) {
63456       {
63457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63458       };
63459     } catch (std::exception& e) {
63460       {
63461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63462       };
63463     } catch (...) {
63464       {
63465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63466       };
63467     }
63468   }
63469   jresult = result;
63470   return jresult;
63471 }
63472
63473
63474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
63475   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63476   float arg2 ;
63477
63478   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63479   arg2 = (float)jarg2;
63480   {
63481     try {
63482       (arg1)->SetIndicatorShowDuration(arg2);
63483     } catch (std::out_of_range& e) {
63484       {
63485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63486       };
63487     } catch (std::exception& e) {
63488       {
63489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63490       };
63491     } catch (...) {
63492       {
63493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63494       };
63495     }
63496   }
63497 }
63498
63499
63500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
63501   float jresult ;
63502   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63503   float result;
63504
63505   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63506   {
63507     try {
63508       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
63509     } catch (std::out_of_range& e) {
63510       {
63511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63512       };
63513     } catch (std::exception& e) {
63514       {
63515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63516       };
63517     } catch (...) {
63518       {
63519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63520       };
63521     }
63522   }
63523   jresult = result;
63524   return jresult;
63525 }
63526
63527
63528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
63529   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63530   float arg2 ;
63531
63532   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63533   arg2 = (float)jarg2;
63534   {
63535     try {
63536       (arg1)->SetIndicatorHideDuration(arg2);
63537     } catch (std::out_of_range& e) {
63538       {
63539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63540       };
63541     } catch (std::exception& e) {
63542       {
63543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63544       };
63545     } catch (...) {
63546       {
63547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63548       };
63549     }
63550   }
63551 }
63552
63553
63554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
63555   float jresult ;
63556   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63557   float result;
63558
63559   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63560   {
63561     try {
63562       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
63563     } catch (std::out_of_range& e) {
63564       {
63565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63566       };
63567     } catch (std::exception& e) {
63568       {
63569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63570       };
63571     } catch (...) {
63572       {
63573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63574       };
63575     }
63576   }
63577   jresult = result;
63578   return jresult;
63579 }
63580
63581
63582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
63583   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63584
63585   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63586   {
63587     try {
63588       (arg1)->ShowIndicator();
63589     } catch (std::out_of_range& e) {
63590       {
63591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63592       };
63593     } catch (std::exception& e) {
63594       {
63595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63596       };
63597     } catch (...) {
63598       {
63599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63600       };
63601     }
63602   }
63603 }
63604
63605
63606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
63607   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63608
63609   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63610   {
63611     try {
63612       (arg1)->HideIndicator();
63613     } catch (std::out_of_range& e) {
63614       {
63615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63616       };
63617     } catch (std::exception& e) {
63618       {
63619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63620       };
63621     } catch (...) {
63622       {
63623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63624       };
63625     }
63626   }
63627 }
63628
63629
63630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
63631   void * jresult ;
63632   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63633   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
63634
63635   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63636   {
63637     try {
63638       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
63639     } catch (std::out_of_range& e) {
63640       {
63641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63642       };
63643     } catch (std::exception& e) {
63644       {
63645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63646       };
63647     } catch (...) {
63648       {
63649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63650       };
63651     }
63652   }
63653   jresult = (void *)result;
63654   return jresult;
63655 }
63656
63657
63658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
63659   void * jresult ;
63660   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63661   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
63662
63663   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63664   {
63665     try {
63666       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
63667     } catch (std::out_of_range& e) {
63668       {
63669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63670       };
63671     } catch (std::exception& e) {
63672       {
63673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63674       };
63675     } catch (...) {
63676       {
63677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63678       };
63679     }
63680   }
63681   jresult = (void *)result;
63682   return jresult;
63683 }
63684
63685
63686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
63687   int jresult ;
63688   int result;
63689
63690   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
63691   jresult = (int)result;
63692   return jresult;
63693 }
63694
63695
63696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
63697   int jresult ;
63698   int result;
63699
63700   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
63701   jresult = (int)result;
63702   return jresult;
63703 }
63704
63705
63706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
63707   int jresult ;
63708   int result;
63709
63710   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
63711   jresult = (int)result;
63712   return jresult;
63713 }
63714
63715
63716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
63717   int jresult ;
63718   int result;
63719
63720   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
63721   jresult = (int)result;
63722   return jresult;
63723 }
63724
63725
63726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
63727   int jresult ;
63728   int result;
63729
63730   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
63731   jresult = (int)result;
63732   return jresult;
63733 }
63734
63735
63736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
63737   int jresult ;
63738   int result;
63739
63740   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
63741   jresult = (int)result;
63742   return jresult;
63743 }
63744
63745
63746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
63747   int jresult ;
63748   int result;
63749
63750   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
63751   jresult = (int)result;
63752   return jresult;
63753 }
63754
63755
63756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
63757   int jresult ;
63758   int result;
63759
63760   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
63761   jresult = (int)result;
63762   return jresult;
63763 }
63764
63765
63766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
63767   int jresult ;
63768   int result;
63769
63770   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
63771   jresult = (int)result;
63772   return jresult;
63773 }
63774
63775
63776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
63777   int jresult ;
63778   int result;
63779
63780   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
63781   jresult = (int)result;
63782   return jresult;
63783 }
63784
63785
63786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
63787   int jresult ;
63788   int result;
63789
63790   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
63791   jresult = (int)result;
63792   return jresult;
63793 }
63794
63795
63796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
63797   int jresult ;
63798   int result;
63799
63800   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
63801   jresult = (int)result;
63802   return jresult;
63803 }
63804
63805
63806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
63807   int jresult ;
63808   int result;
63809
63810   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
63811   jresult = (int)result;
63812   return jresult;
63813 }
63814
63815
63816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
63817   int jresult ;
63818   int result;
63819
63820   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
63821   jresult = (int)result;
63822   return jresult;
63823 }
63824
63825
63826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
63827   void * jresult ;
63828   Dali::Toolkit::Scrollable::Property *result = 0 ;
63829
63830   {
63831     try {
63832       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
63833     } catch (std::out_of_range& e) {
63834       {
63835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63836       };
63837     } catch (std::exception& e) {
63838       {
63839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63840       };
63841     } catch (...) {
63842       {
63843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63844       };
63845     }
63846   }
63847   jresult = (void *)result;
63848   return jresult;
63849 }
63850
63851
63852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
63853   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
63854
63855   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
63856   {
63857     try {
63858       delete arg1;
63859     } catch (std::out_of_range& e) {
63860       {
63861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63862       };
63863     } catch (std::exception& e) {
63864       {
63865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63866       };
63867     } catch (...) {
63868       {
63869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63870       };
63871     }
63872   }
63873 }
63874
63875
63876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
63877   void * jresult ;
63878   Dali::Toolkit::Scrollable *result = 0 ;
63879
63880   {
63881     try {
63882       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
63883     } catch (std::out_of_range& e) {
63884       {
63885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63886       };
63887     } catch (std::exception& e) {
63888       {
63889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63890       };
63891     } catch (...) {
63892       {
63893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63894       };
63895     }
63896   }
63897   jresult = (void *)result;
63898   return jresult;
63899 }
63900
63901
63902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
63903   void * jresult ;
63904   Dali::Toolkit::Scrollable *arg1 = 0 ;
63905   Dali::Toolkit::Scrollable *result = 0 ;
63906
63907   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63908   if (!arg1) {
63909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63910     return 0;
63911   }
63912   {
63913     try {
63914       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
63915     } catch (std::out_of_range& e) {
63916       {
63917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63918       };
63919     } catch (std::exception& e) {
63920       {
63921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63922       };
63923     } catch (...) {
63924       {
63925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63926       };
63927     }
63928   }
63929   jresult = (void *)result;
63930   return jresult;
63931 }
63932
63933
63934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
63935   void * jresult ;
63936   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63937   Dali::Toolkit::Scrollable *arg2 = 0 ;
63938   Dali::Toolkit::Scrollable *result = 0 ;
63939
63940   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63941   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
63942   if (!arg2) {
63943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
63944     return 0;
63945   }
63946   {
63947     try {
63948       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
63949     } catch (std::out_of_range& e) {
63950       {
63951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63952       };
63953     } catch (std::exception& e) {
63954       {
63955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63956       };
63957     } catch (...) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63960       };
63961     }
63962   }
63963   jresult = (void *)result;
63964   return jresult;
63965 }
63966
63967
63968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
63969   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
63970
63971   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
63972   {
63973     try {
63974       delete arg1;
63975     } catch (std::out_of_range& e) {
63976       {
63977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63978       };
63979     } catch (std::exception& e) {
63980       {
63981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63982       };
63983     } catch (...) {
63984       {
63985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63986       };
63987     }
63988   }
63989 }
63990
63991
63992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
63993   void * jresult ;
63994   Dali::BaseHandle arg1 ;
63995   Dali::BaseHandle *argp1 ;
63996   Dali::Toolkit::Scrollable result;
63997
63998   argp1 = (Dali::BaseHandle *)jarg1;
63999   if (!argp1) {
64000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64001     return 0;
64002   }
64003   arg1 = *argp1;
64004   {
64005     try {
64006       result = Dali::Toolkit::Scrollable::DownCast(arg1);
64007     } catch (std::out_of_range& e) {
64008       {
64009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64010       };
64011     } catch (std::exception& e) {
64012       {
64013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64014       };
64015     } catch (...) {
64016       {
64017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64018       };
64019     }
64020   }
64021   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
64022   return jresult;
64023 }
64024
64025
64026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
64027   unsigned int jresult ;
64028   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64029   bool result;
64030
64031   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64032   {
64033     try {
64034       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
64035     } catch (std::out_of_range& e) {
64036       {
64037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64038       };
64039     } catch (std::exception& e) {
64040       {
64041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64042       };
64043     } catch (...) {
64044       {
64045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64046       };
64047     }
64048   }
64049   jresult = result;
64050   return jresult;
64051 }
64052
64053
64054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
64055   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64056   bool arg2 ;
64057
64058   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64059   arg2 = jarg2 ? true : false;
64060   {
64061     try {
64062       (arg1)->SetOvershootEnabled(arg2);
64063     } catch (std::out_of_range& e) {
64064       {
64065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64066       };
64067     } catch (std::exception& e) {
64068       {
64069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64070       };
64071     } catch (...) {
64072       {
64073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64074       };
64075     }
64076   }
64077 }
64078
64079
64080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
64081   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64082   Dali::Vector4 *arg2 = 0 ;
64083
64084   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64085   arg2 = (Dali::Vector4 *)jarg2;
64086   if (!arg2) {
64087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
64088     return ;
64089   }
64090   {
64091     try {
64092       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
64093     } catch (std::out_of_range& e) {
64094       {
64095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64096       };
64097     } catch (std::exception& e) {
64098       {
64099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64100       };
64101     } catch (...) {
64102       {
64103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64104       };
64105     }
64106   }
64107 }
64108
64109
64110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
64111   void * jresult ;
64112   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64113   Dali::Vector4 result;
64114
64115   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64116   {
64117     try {
64118       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
64119     } catch (std::out_of_range& e) {
64120       {
64121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64122       };
64123     } catch (std::exception& e) {
64124       {
64125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64126       };
64127     } catch (...) {
64128       {
64129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64130       };
64131     }
64132   }
64133   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64134   return jresult;
64135 }
64136
64137
64138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
64139   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64140   float arg2 ;
64141
64142   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64143   arg2 = (float)jarg2;
64144   {
64145     try {
64146       (arg1)->SetOvershootAnimationSpeed(arg2);
64147     } catch (std::out_of_range& e) {
64148       {
64149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64150       };
64151     } catch (std::exception& e) {
64152       {
64153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64154       };
64155     } catch (...) {
64156       {
64157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64158       };
64159     }
64160   }
64161 }
64162
64163
64164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
64165   float jresult ;
64166   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64167   float result;
64168
64169   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64170   {
64171     try {
64172       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
64173     } catch (std::out_of_range& e) {
64174       {
64175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64176       };
64177     } catch (std::exception& e) {
64178       {
64179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64180       };
64181     } catch (...) {
64182       {
64183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64184       };
64185     }
64186   }
64187   jresult = result;
64188   return jresult;
64189 }
64190
64191
64192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
64193   void * jresult ;
64194   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64195   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
64196
64197   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64198   {
64199     try {
64200       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
64201     } catch (std::out_of_range& e) {
64202       {
64203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64204       };
64205     } catch (std::exception& e) {
64206       {
64207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64208       };
64209     } catch (...) {
64210       {
64211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64212       };
64213     }
64214   }
64215   jresult = (void *)result;
64216   return jresult;
64217 }
64218
64219
64220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
64221   void * jresult ;
64222   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64223   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
64224
64225   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64226   {
64227     try {
64228       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
64229     } catch (std::out_of_range& e) {
64230       {
64231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64232       };
64233     } catch (std::exception& e) {
64234       {
64235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64236       };
64237     } catch (...) {
64238       {
64239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64240       };
64241     }
64242   }
64243   jresult = (void *)result;
64244   return jresult;
64245 }
64246
64247
64248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
64249   void * jresult ;
64250   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64251   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
64252
64253   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64254   {
64255     try {
64256       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
64257     } catch (std::out_of_range& e) {
64258       {
64259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64260       };
64261     } catch (std::exception& e) {
64262       {
64263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64264       };
64265     } catch (...) {
64266       {
64267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64268       };
64269     }
64270   }
64271   jresult = (void *)result;
64272   return jresult;
64273 }
64274
64275
64276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
64277   unsigned int jresult ;
64278   Dali::Toolkit::ControlOrientation::Type arg1 ;
64279   bool result;
64280
64281   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64282   {
64283     try {
64284       result = (bool)Dali::Toolkit::IsVertical(arg1);
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 = result;
64300   return jresult;
64301 }
64302
64303
64304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
64305   unsigned int jresult ;
64306   Dali::Toolkit::ControlOrientation::Type arg1 ;
64307   bool result;
64308
64309   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64310   {
64311     try {
64312       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
64313     } catch (std::out_of_range& e) {
64314       {
64315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64316       };
64317     } catch (std::exception& e) {
64318       {
64319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64320       };
64321     } catch (...) {
64322       {
64323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64324       };
64325     }
64326   }
64327   jresult = result;
64328   return jresult;
64329 }
64330
64331
64332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
64333   void * jresult ;
64334   unsigned int arg1 ;
64335   unsigned int arg2 ;
64336   Dali::Toolkit::ItemRange *result = 0 ;
64337
64338   arg1 = (unsigned int)jarg1;
64339   arg2 = (unsigned int)jarg2;
64340   {
64341     try {
64342       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
64343     } catch (std::out_of_range& e) {
64344       {
64345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64346       };
64347     } catch (std::exception& e) {
64348       {
64349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64350       };
64351     } catch (...) {
64352       {
64353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64354       };
64355     }
64356   }
64357   jresult = (void *)result;
64358   return jresult;
64359 }
64360
64361
64362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
64363   void * jresult ;
64364   Dali::Toolkit::ItemRange *arg1 = 0 ;
64365   Dali::Toolkit::ItemRange *result = 0 ;
64366
64367   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64368   if (!arg1) {
64369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64370     return 0;
64371   }
64372   {
64373     try {
64374       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
64375     } catch (std::out_of_range& e) {
64376       {
64377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64378       };
64379     } catch (std::exception& e) {
64380       {
64381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64382       };
64383     } catch (...) {
64384       {
64385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64386       };
64387     }
64388   }
64389   jresult = (void *)result;
64390   return jresult;
64391 }
64392
64393
64394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
64395   void * jresult ;
64396   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64397   Dali::Toolkit::ItemRange *arg2 = 0 ;
64398   Dali::Toolkit::ItemRange *result = 0 ;
64399
64400   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64401   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64402   if (!arg2) {
64403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64404     return 0;
64405   }
64406   {
64407     try {
64408       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
64409     } catch (std::out_of_range& e) {
64410       {
64411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64412       };
64413     } catch (std::exception& e) {
64414       {
64415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64416       };
64417     } catch (...) {
64418       {
64419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64420       };
64421     }
64422   }
64423   jresult = (void *)result;
64424   return jresult;
64425 }
64426
64427
64428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
64429   unsigned int jresult ;
64430   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64431   unsigned int arg2 ;
64432   bool result;
64433
64434   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64435   arg2 = (unsigned int)jarg2;
64436   {
64437     try {
64438       result = (bool)(arg1)->Within(arg2);
64439     } catch (std::out_of_range& e) {
64440       {
64441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64442       };
64443     } catch (std::exception& e) {
64444       {
64445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64446       };
64447     } catch (...) {
64448       {
64449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64450       };
64451     }
64452   }
64453   jresult = result;
64454   return jresult;
64455 }
64456
64457
64458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
64459   void * jresult ;
64460   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64461   Dali::Toolkit::ItemRange *arg2 = 0 ;
64462   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64463
64464   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64465   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64466   if (!arg2) {
64467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64468     return 0;
64469   }
64470   {
64471     try {
64472       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
64473     } catch (std::out_of_range& e) {
64474       {
64475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64476       };
64477     } catch (std::exception& e) {
64478       {
64479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64480       };
64481     } catch (...) {
64482       {
64483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64484       };
64485     }
64486   }
64487   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64488   return jresult;
64489 }
64490
64491
64492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
64493   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64494   unsigned int arg2 ;
64495
64496   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64497   arg2 = (unsigned int)jarg2;
64498   if (arg1) (arg1)->begin = arg2;
64499 }
64500
64501
64502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
64503   unsigned int jresult ;
64504   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64505   unsigned int result;
64506
64507   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64508   result = (unsigned int) ((arg1)->begin);
64509   jresult = result;
64510   return jresult;
64511 }
64512
64513
64514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
64515   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64516   unsigned int arg2 ;
64517
64518   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64519   arg2 = (unsigned int)jarg2;
64520   if (arg1) (arg1)->end = arg2;
64521 }
64522
64523
64524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
64525   unsigned int jresult ;
64526   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64527   unsigned int result;
64528
64529   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64530   result = (unsigned int) ((arg1)->end);
64531   jresult = result;
64532   return jresult;
64533 }
64534
64535
64536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
64537   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64538
64539   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64540   {
64541     try {
64542       delete arg1;
64543     } catch (std::out_of_range& e) {
64544       {
64545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64546       };
64547     } catch (std::exception& e) {
64548       {
64549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64550       };
64551     } catch (...) {
64552       {
64553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64554       };
64555     }
64556   }
64557 }
64558
64559
64560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
64561   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64562
64563   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64564   {
64565     try {
64566       delete arg1;
64567     } catch (std::out_of_range& e) {
64568       {
64569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64570       };
64571     } catch (std::exception& e) {
64572       {
64573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64574       };
64575     } catch (...) {
64576       {
64577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64578       };
64579     }
64580   }
64581 }
64582
64583
64584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
64585   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64586   Dali::Toolkit::ControlOrientation::Type arg2 ;
64587
64588   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64589   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
64590   {
64591     try {
64592       (arg1)->SetOrientation(arg2);
64593     } catch (std::out_of_range& e) {
64594       {
64595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64596       };
64597     } catch (std::exception& e) {
64598       {
64599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64600       };
64601     } catch (...) {
64602       {
64603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64604       };
64605     }
64606   }
64607 }
64608
64609
64610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
64611   int jresult ;
64612   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64613   Dali::Toolkit::ControlOrientation::Type result;
64614
64615   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64616   {
64617     try {
64618       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
64619     } catch (std::out_of_range& e) {
64620       {
64621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64622       };
64623     } catch (std::exception& e) {
64624       {
64625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64626       };
64627     } catch (...) {
64628       {
64629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64630       };
64631     }
64632   }
64633   jresult = (int)result;
64634   return jresult;
64635 }
64636
64637
64638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
64639   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64640   Dali::Property::Map *arg2 = 0 ;
64641
64642   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64643   arg2 = (Dali::Property::Map *)jarg2;
64644   if (!arg2) {
64645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
64646     return ;
64647   }
64648   {
64649     try {
64650       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
64651     } catch (std::out_of_range& e) {
64652       {
64653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64654       };
64655     } catch (std::exception& e) {
64656       {
64657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64658       };
64659     } catch (...) {
64660       {
64661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64662       };
64663     }
64664   }
64665 }
64666
64667
64668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
64669   void * jresult ;
64670   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64671   Dali::Property::Map result;
64672
64673   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64674   {
64675     try {
64676       result = (arg1)->GetLayoutProperties();
64677     } catch (std::out_of_range& e) {
64678       {
64679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64680       };
64681     } catch (std::exception& e) {
64682       {
64683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64684       };
64685     } catch (...) {
64686       {
64687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64688       };
64689     }
64690   }
64691   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
64692   return jresult;
64693 }
64694
64695
64696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64697   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64698   unsigned int arg2 ;
64699   Dali::Vector3 *arg3 = 0 ;
64700   Dali::Vector3 *arg4 = 0 ;
64701
64702   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64703   arg2 = (unsigned int)jarg2;
64704   arg3 = (Dali::Vector3 *)jarg3;
64705   if (!arg3) {
64706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64707     return ;
64708   }
64709   arg4 = (Dali::Vector3 *)jarg4;
64710   if (!arg4) {
64711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64712     return ;
64713   }
64714   {
64715     try {
64716       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64717     } catch (std::out_of_range& e) {
64718       {
64719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64720       };
64721     } catch (std::exception& e) {
64722       {
64723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64724       };
64725     } catch (...) {
64726       {
64727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64728       };
64729     }
64730   }
64731 }
64732
64733
64734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
64735   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64736   Dali::Vector3 *arg2 = 0 ;
64737
64738   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64739   arg2 = (Dali::Vector3 *)jarg2;
64740   if (!arg2) {
64741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64742     return ;
64743   }
64744   {
64745     try {
64746       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
64747     } catch (std::out_of_range& e) {
64748       {
64749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64750       };
64751     } catch (std::exception& e) {
64752       {
64753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64754       };
64755     } catch (...) {
64756       {
64757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64758       };
64759     }
64760   }
64761 }
64762
64763
64764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
64765   float jresult ;
64766   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64767   unsigned int arg2 ;
64768   Dali::Vector3 arg3 ;
64769   Dali::Vector3 *argp3 ;
64770   float result;
64771
64772   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64773   arg2 = (unsigned int)jarg2;
64774   argp3 = (Dali::Vector3 *)jarg3;
64775   if (!argp3) {
64776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64777     return 0;
64778   }
64779   arg3 = *argp3;
64780   {
64781     try {
64782       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
64783     } catch (std::out_of_range& e) {
64784       {
64785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64786       };
64787     } catch (std::exception& e) {
64788       {
64789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64790       };
64791     } catch (...) {
64792       {
64793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64794       };
64795     }
64796   }
64797   jresult = result;
64798   return jresult;
64799 }
64800
64801
64802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
64803   float jresult ;
64804   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64805   float arg2 ;
64806   float result;
64807
64808   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64809   arg2 = (float)jarg2;
64810   {
64811     try {
64812       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
64813     } catch (std::out_of_range& e) {
64814       {
64815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64816       };
64817     } catch (std::exception& e) {
64818       {
64819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64820       };
64821     } catch (...) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64824       };
64825     }
64826   }
64827   jresult = result;
64828   return jresult;
64829 }
64830
64831
64832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
64833   float jresult ;
64834   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64835   unsigned int arg2 ;
64836   float result;
64837
64838   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64839   arg2 = (unsigned int)jarg2;
64840   {
64841     try {
64842       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
64843     } catch (std::out_of_range& e) {
64844       {
64845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64846       };
64847     } catch (std::exception& e) {
64848       {
64849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64850       };
64851     } catch (...) {
64852       {
64853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64854       };
64855     }
64856   }
64857   jresult = result;
64858   return jresult;
64859 }
64860
64861
64862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
64863   void * jresult ;
64864   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64865   float arg2 ;
64866   Dali::Vector3 arg3 ;
64867   Dali::Vector3 *argp3 ;
64868   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64869
64870   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64871   arg2 = (float)jarg2;
64872   argp3 = (Dali::Vector3 *)jarg3;
64873   if (!argp3) {
64874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64875     return 0;
64876   }
64877   arg3 = *argp3;
64878   {
64879     try {
64880       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
64881     } catch (std::out_of_range& e) {
64882       {
64883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64884       };
64885     } catch (std::exception& e) {
64886       {
64887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64888       };
64889     } catch (...) {
64890       {
64891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64892       };
64893     }
64894   }
64895   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64896   return jresult;
64897 }
64898
64899
64900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
64901   float jresult ;
64902   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64903   int arg2 ;
64904   float arg3 ;
64905   Dali::Vector3 *arg4 = 0 ;
64906   float result;
64907
64908   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64909   arg2 = (int)jarg2;
64910   arg3 = (float)jarg3;
64911   arg4 = (Dali::Vector3 *)jarg4;
64912   if (!arg4) {
64913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64914     return 0;
64915   }
64916   {
64917     try {
64918       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
64919     } catch (std::out_of_range& e) {
64920       {
64921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64922       };
64923     } catch (std::exception& e) {
64924       {
64925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64926       };
64927     } catch (...) {
64928       {
64929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64930       };
64931     }
64932   }
64933   jresult = result;
64934   return jresult;
64935 }
64936
64937
64938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
64939   unsigned int jresult ;
64940   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64941   Dali::Vector3 arg2 ;
64942   Dali::Vector3 *argp2 ;
64943   unsigned int result;
64944
64945   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64946   argp2 = (Dali::Vector3 *)jarg2;
64947   if (!argp2) {
64948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64949     return 0;
64950   }
64951   arg2 = *argp2;
64952   {
64953     try {
64954       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
64955     } catch (std::out_of_range& e) {
64956       {
64957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64958       };
64959     } catch (std::exception& e) {
64960       {
64961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64962       };
64963     } catch (...) {
64964       {
64965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64966       };
64967     }
64968   }
64969   jresult = result;
64970   return jresult;
64971 }
64972
64973
64974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64975   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64976   unsigned int arg2 ;
64977   Dali::Vector3 *arg3 = 0 ;
64978   Dali::Vector3 *arg4 = 0 ;
64979
64980   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64981   arg2 = (unsigned int)jarg2;
64982   arg3 = (Dali::Vector3 *)jarg3;
64983   if (!arg3) {
64984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64985     return ;
64986   }
64987   arg4 = (Dali::Vector3 *)jarg4;
64988   if (!arg4) {
64989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64990     return ;
64991   }
64992   {
64993     try {
64994       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64995     } catch (std::out_of_range& e) {
64996       {
64997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64998       };
64999     } catch (std::exception& e) {
65000       {
65001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65002       };
65003     } catch (...) {
65004       {
65005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65006       };
65007     }
65008   }
65009 }
65010
65011
65012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
65013   void * jresult ;
65014   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65015   Dali::Degree result;
65016
65017   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65018   {
65019     try {
65020       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
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::Degree((const Dali::Degree &)result);
65036   return jresult;
65037 }
65038
65039
65040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
65041   float jresult ;
65042   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65043   float result;
65044
65045   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65046   {
65047     try {
65048       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
65049     } catch (std::out_of_range& e) {
65050       {
65051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65052       };
65053     } catch (std::exception& e) {
65054       {
65055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65056       };
65057     } catch (...) {
65058       {
65059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65060       };
65061     }
65062   }
65063   jresult = result;
65064   return jresult;
65065 }
65066
65067
65068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
65069   float jresult ;
65070   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65071   float result;
65072
65073   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65074   {
65075     try {
65076       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
65077     } catch (std::out_of_range& e) {
65078       {
65079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65080       };
65081     } catch (std::exception& e) {
65082       {
65083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65084       };
65085     } catch (...) {
65086       {
65087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65088       };
65089     }
65090   }
65091   jresult = result;
65092   return jresult;
65093 }
65094
65095
65096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
65097   float jresult ;
65098   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65099   float result;
65100
65101   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65102   {
65103     try {
65104       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
65105     } catch (std::out_of_range& e) {
65106       {
65107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65108       };
65109     } catch (std::exception& e) {
65110       {
65111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65112       };
65113     } catch (...) {
65114       {
65115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65116       };
65117     }
65118   }
65119   jresult = result;
65120   return jresult;
65121 }
65122
65123
65124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
65125   int jresult ;
65126   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65127   int arg2 ;
65128   int arg3 ;
65129   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
65130   bool arg5 ;
65131   int result;
65132
65133   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65134   arg2 = (int)jarg2;
65135   arg3 = (int)jarg3;
65136   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
65137   arg5 = jarg5 ? true : false;
65138   {
65139     try {
65140       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
65141     } catch (std::out_of_range& e) {
65142       {
65143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65144       };
65145     } catch (std::exception& e) {
65146       {
65147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65148       };
65149     } catch (...) {
65150       {
65151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65152       };
65153     }
65154   }
65155   jresult = result;
65156   return jresult;
65157 }
65158
65159
65160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
65161   float jresult ;
65162   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65163   float result;
65164
65165   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65166   {
65167     try {
65168       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
65169     } catch (std::out_of_range& e) {
65170       {
65171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65172       };
65173     } catch (std::exception& e) {
65174       {
65175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65176       };
65177     } catch (...) {
65178       {
65179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65180       };
65181     }
65182   }
65183   jresult = result;
65184   return jresult;
65185 }
65186
65187
65188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
65189   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65190   Dali::Actor *arg2 = 0 ;
65191   int arg3 ;
65192   Dali::Vector3 *arg4 = 0 ;
65193   Dali::Actor *arg5 = 0 ;
65194
65195   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65196   arg2 = (Dali::Actor *)jarg2;
65197   if (!arg2) {
65198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65199     return ;
65200   }
65201   arg3 = (int)jarg3;
65202   arg4 = (Dali::Vector3 *)jarg4;
65203   if (!arg4) {
65204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65205     return ;
65206   }
65207   arg5 = (Dali::Actor *)jarg5;
65208   if (!arg5) {
65209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65210     return ;
65211   }
65212   {
65213     try {
65214       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
65215     } catch (std::out_of_range& e) {
65216       {
65217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65218       };
65219     } catch (std::exception& e) {
65220       {
65221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65222       };
65223     } catch (...) {
65224       {
65225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65226       };
65227     }
65228   }
65229 }
65230
65231
65232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65233   void * jresult ;
65234   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65235   int arg2 ;
65236   float arg3 ;
65237   Dali::Vector3 *arg4 = 0 ;
65238   Dali::Vector3 result;
65239
65240   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65241   arg2 = (int)jarg2;
65242   arg3 = (float)jarg3;
65243   arg4 = (Dali::Vector3 *)jarg4;
65244   if (!arg4) {
65245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65246     return 0;
65247   }
65248   {
65249     try {
65250       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65251     } catch (std::out_of_range& e) {
65252       {
65253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65254       };
65255     } catch (std::exception& e) {
65256       {
65257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65258       };
65259     } catch (...) {
65260       {
65261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65262       };
65263     }
65264   }
65265   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65266   return jresult;
65267 }
65268
65269
65270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
65271   void * jresult ;
65272   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
65273   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65274
65275   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
65276   {
65277     try {
65278       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
65279     } catch (std::out_of_range& e) {
65280       {
65281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65282       };
65283     } catch (std::exception& e) {
65284       {
65285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65286       };
65287     } catch (...) {
65288       {
65289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65290       };
65291     }
65292   }
65293   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65294   return jresult;
65295 }
65296
65297
65298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
65299   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65300
65301   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65302   {
65303     try {
65304       delete arg1;
65305     } catch (std::out_of_range& e) {
65306       {
65307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65308       };
65309     } catch (std::exception& e) {
65310       {
65311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65312       };
65313     } catch (...) {
65314       {
65315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65316       };
65317     }
65318   }
65319 }
65320
65321
65322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
65323   unsigned int jresult ;
65324   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65325   unsigned int result;
65326
65327   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65328   {
65329     try {
65330       result = (unsigned int)(arg1)->GetNumberOfItems();
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 = result;
65346   return jresult;
65347 }
65348
65349
65350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
65351   void * jresult ;
65352   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65353   unsigned int arg2 ;
65354   Dali::Actor result;
65355
65356   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65357   arg2 = (unsigned int)jarg2;
65358   {
65359     try {
65360       result = (arg1)->NewItem(arg2);
65361     } catch (std::out_of_range& e) {
65362       {
65363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65364       };
65365     } catch (std::exception& e) {
65366       {
65367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65368       };
65369     } catch (...) {
65370       {
65371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65372       };
65373     }
65374   }
65375   jresult = new Dali::Actor((const Dali::Actor &)result);
65376   return jresult;
65377 }
65378
65379
65380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
65381   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65382   unsigned int arg2 ;
65383   Dali::Actor arg3 ;
65384   Dali::Actor *argp3 ;
65385
65386   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65387   arg2 = (unsigned int)jarg2;
65388   argp3 = (Dali::Actor *)jarg3;
65389   if (!argp3) {
65390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65391     return ;
65392   }
65393   arg3 = *argp3;
65394   {
65395     try {
65396       (arg1)->ItemReleased(arg2,arg3);
65397     } catch (std::out_of_range& e) {
65398       {
65399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65400       };
65401     } catch (std::exception& e) {
65402       {
65403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65404       };
65405     } catch (...) {
65406       {
65407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65408       };
65409     }
65410   }
65411 }
65412
65413
65414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
65415   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65416   unsigned int arg2 ;
65417   Dali::Actor arg3 ;
65418   Dali::Actor *argp3 ;
65419
65420   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65421   arg2 = (unsigned int)jarg2;
65422   argp3 = (Dali::Actor *)jarg3;
65423   if (!argp3) {
65424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65425     return ;
65426   }
65427   arg3 = *argp3;
65428   {
65429     try {
65430       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
65431     } catch (std::out_of_range& e) {
65432       {
65433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65434       };
65435     } catch (std::exception& e) {
65436       {
65437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65438       };
65439     } catch (...) {
65440       {
65441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65442       };
65443     }
65444   }
65445 }
65446
65447
65448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
65449   void * jresult ;
65450   Dali::Toolkit::ItemFactory *result = 0 ;
65451
65452   {
65453     try {
65454       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
65455     } catch (std::out_of_range& e) {
65456       {
65457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65458       };
65459     } catch (std::exception& e) {
65460       {
65461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65462       };
65463     } catch (...) {
65464       {
65465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65466       };
65467     }
65468   }
65469   jresult = (void *)result;
65470   return jresult;
65471 }
65472
65473
65474 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) {
65475   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
65476   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
65477   if (director) {
65478     director->swig_connect_director(callback0, callback1, callback2);
65479   }
65480 }
65481
65482
65483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
65484   int jresult ;
65485   int result;
65486
65487   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
65488   jresult = (int)result;
65489   return jresult;
65490 }
65491
65492
65493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
65494   int jresult ;
65495   int result;
65496
65497   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
65498   jresult = (int)result;
65499   return jresult;
65500 }
65501
65502
65503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
65504   int jresult ;
65505   int result;
65506
65507   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
65508   jresult = (int)result;
65509   return jresult;
65510 }
65511
65512
65513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
65514   int jresult ;
65515   int result;
65516
65517   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
65518   jresult = (int)result;
65519   return jresult;
65520 }
65521
65522
65523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
65524   int jresult ;
65525   int result;
65526
65527   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
65528   jresult = (int)result;
65529   return jresult;
65530 }
65531
65532
65533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
65534   int jresult ;
65535   int result;
65536
65537   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
65538   jresult = (int)result;
65539   return jresult;
65540 }
65541
65542
65543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
65544   int jresult ;
65545   int result;
65546
65547   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
65548   jresult = (int)result;
65549   return jresult;
65550 }
65551
65552
65553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
65554   int jresult ;
65555   int result;
65556
65557   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
65558   jresult = (int)result;
65559   return jresult;
65560 }
65561
65562
65563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
65564   int jresult ;
65565   int result;
65566
65567   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
65568   jresult = (int)result;
65569   return jresult;
65570 }
65571
65572
65573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
65574   int jresult ;
65575   int result;
65576
65577   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
65578   jresult = (int)result;
65579   return jresult;
65580 }
65581
65582
65583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
65584   int jresult ;
65585   int result;
65586
65587   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
65588   jresult = (int)result;
65589   return jresult;
65590 }
65591
65592
65593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
65594   void * jresult ;
65595   Dali::Toolkit::ItemView::Property *result = 0 ;
65596
65597   {
65598     try {
65599       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
65600     } catch (std::out_of_range& e) {
65601       {
65602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65603       };
65604     } catch (std::exception& e) {
65605       {
65606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65607       };
65608     } catch (...) {
65609       {
65610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65611       };
65612     }
65613   }
65614   jresult = (void *)result;
65615   return jresult;
65616 }
65617
65618
65619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
65620   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
65621
65622   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
65623   {
65624     try {
65625       delete arg1;
65626     } catch (std::out_of_range& e) {
65627       {
65628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65629       };
65630     } catch (std::exception& e) {
65631       {
65632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65633       };
65634     } catch (...) {
65635       {
65636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65637       };
65638     }
65639   }
65640 }
65641
65642
65643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
65644   void * jresult ;
65645   Dali::Toolkit::ItemView *result = 0 ;
65646
65647   {
65648     try {
65649       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
65650     } catch (std::out_of_range& e) {
65651       {
65652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65653       };
65654     } catch (std::exception& e) {
65655       {
65656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65657       };
65658     } catch (...) {
65659       {
65660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65661       };
65662     }
65663   }
65664   jresult = (void *)result;
65665   return jresult;
65666 }
65667
65668
65669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
65670   void * jresult ;
65671   Dali::Toolkit::ItemView *arg1 = 0 ;
65672   Dali::Toolkit::ItemView *result = 0 ;
65673
65674   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65675   if (!arg1) {
65676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65677     return 0;
65678   }
65679   {
65680     try {
65681       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
65682     } catch (std::out_of_range& e) {
65683       {
65684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65685       };
65686     } catch (std::exception& e) {
65687       {
65688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65689       };
65690     } catch (...) {
65691       {
65692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65693       };
65694     }
65695   }
65696   jresult = (void *)result;
65697   return jresult;
65698 }
65699
65700
65701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
65702   void * jresult ;
65703   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65704   Dali::Toolkit::ItemView *arg2 = 0 ;
65705   Dali::Toolkit::ItemView *result = 0 ;
65706
65707   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65708   arg2 = (Dali::Toolkit::ItemView *)jarg2;
65709   if (!arg2) {
65710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65711     return 0;
65712   }
65713   {
65714     try {
65715       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
65716     } catch (std::out_of_range& e) {
65717       {
65718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65719       };
65720     } catch (std::exception& e) {
65721       {
65722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65723       };
65724     } catch (...) {
65725       {
65726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65727       };
65728     }
65729   }
65730   jresult = (void *)result;
65731   return jresult;
65732 }
65733
65734
65735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
65736   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65737
65738   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65739   {
65740     try {
65741       delete arg1;
65742     } catch (std::out_of_range& e) {
65743       {
65744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65745       };
65746     } catch (std::exception& e) {
65747       {
65748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65749       };
65750     } catch (...) {
65751       {
65752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65753       };
65754     }
65755   }
65756 }
65757
65758
65759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
65760   void * jresult ;
65761   Dali::Toolkit::ItemFactory *arg1 = 0 ;
65762   Dali::Toolkit::ItemView result;
65763
65764   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65765   if (!arg1) {
65766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
65767     return 0;
65768   }
65769   {
65770     try {
65771       result = Dali::Toolkit::ItemView::New(*arg1);
65772     } catch (std::out_of_range& e) {
65773       {
65774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65775       };
65776     } catch (std::exception& e) {
65777       {
65778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65779       };
65780     } catch (...) {
65781       {
65782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65783       };
65784     }
65785   }
65786   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65787   return jresult;
65788 }
65789
65790
65791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
65792   void * jresult ;
65793   Dali::BaseHandle arg1 ;
65794   Dali::BaseHandle *argp1 ;
65795   Dali::Toolkit::ItemView result;
65796
65797   argp1 = (Dali::BaseHandle *)jarg1;
65798   if (!argp1) {
65799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65800     return 0;
65801   }
65802   arg1 = *argp1;
65803   {
65804     try {
65805       result = Dali::Toolkit::ItemView::DownCast(arg1);
65806     } catch (std::out_of_range& e) {
65807       {
65808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65809       };
65810     } catch (std::exception& e) {
65811       {
65812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65813       };
65814     } catch (...) {
65815       {
65816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65817       };
65818     }
65819   }
65820   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65821   return jresult;
65822 }
65823
65824
65825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
65826   unsigned int jresult ;
65827   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65828   unsigned int result;
65829
65830   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65831   {
65832     try {
65833       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
65834     } catch (std::out_of_range& e) {
65835       {
65836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65837       };
65838     } catch (std::exception& e) {
65839       {
65840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65841       };
65842     } catch (...) {
65843       {
65844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65845       };
65846     }
65847   }
65848   jresult = result;
65849   return jresult;
65850 }
65851
65852
65853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
65854   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65855   Dali::Toolkit::ItemLayout *arg2 = 0 ;
65856
65857   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65858   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
65859   if (!arg2) {
65860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
65861     return ;
65862   }
65863   {
65864     try {
65865       (arg1)->AddLayout(*arg2);
65866     } catch (std::out_of_range& e) {
65867       {
65868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65869       };
65870     } catch (std::exception& e) {
65871       {
65872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65873       };
65874     } catch (...) {
65875       {
65876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65877       };
65878     }
65879   }
65880 }
65881
65882
65883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
65884   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65885   unsigned int arg2 ;
65886
65887   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65888   arg2 = (unsigned int)jarg2;
65889   {
65890     try {
65891       (arg1)->RemoveLayout(arg2);
65892     } catch (std::out_of_range& e) {
65893       {
65894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65895       };
65896     } catch (std::exception& e) {
65897       {
65898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65899       };
65900     } catch (...) {
65901       {
65902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65903       };
65904     }
65905   }
65906 }
65907
65908
65909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
65910   void * jresult ;
65911   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65912   unsigned int arg2 ;
65913   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65914
65915   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65916   arg2 = (unsigned int)jarg2;
65917   {
65918     try {
65919       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
65920     } catch (std::out_of_range& e) {
65921       {
65922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65923       };
65924     } catch (std::exception& e) {
65925       {
65926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65927       };
65928     } catch (...) {
65929       {
65930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65931       };
65932     }
65933   }
65934   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65935   return jresult;
65936 }
65937
65938
65939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
65940   void * jresult ;
65941   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65942   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65943
65944   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65945   {
65946     try {
65947       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
65948     } catch (std::out_of_range& e) {
65949       {
65950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65951       };
65952     } catch (std::exception& e) {
65953       {
65954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65955       };
65956     } catch (...) {
65957       {
65958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65959       };
65960     }
65961   }
65962   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65963   return jresult;
65964 }
65965
65966
65967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
65968   float jresult ;
65969   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65970   Dali::Toolkit::ItemId arg2 ;
65971   float result;
65972
65973   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65974   arg2 = (Dali::Toolkit::ItemId)jarg2;
65975   {
65976     try {
65977       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
65978     } catch (std::out_of_range& e) {
65979       {
65980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65981       };
65982     } catch (std::exception& e) {
65983       {
65984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65985       };
65986     } catch (...) {
65987       {
65988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65989       };
65990     }
65991   }
65992   jresult = result;
65993   return jresult;
65994 }
65995
65996
65997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
65998   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65999   unsigned int arg2 ;
66000   Dali::Vector3 arg3 ;
66001   float arg4 ;
66002   Dali::Vector3 *argp3 ;
66003
66004   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66005   arg2 = (unsigned int)jarg2;
66006   argp3 = (Dali::Vector3 *)jarg3;
66007   if (!argp3) {
66008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
66009     return ;
66010   }
66011   arg3 = *argp3;
66012   arg4 = (float)jarg4;
66013   {
66014     try {
66015       (arg1)->ActivateLayout(arg2,arg3,arg4);
66016     } catch (std::out_of_range& e) {
66017       {
66018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66019       };
66020     } catch (std::exception& e) {
66021       {
66022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66023       };
66024     } catch (...) {
66025       {
66026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66027       };
66028     }
66029   }
66030 }
66031
66032
66033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
66034   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66035
66036   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66037   {
66038     try {
66039       (arg1)->DeactivateCurrentLayout();
66040     } catch (std::out_of_range& e) {
66041       {
66042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66043       };
66044     } catch (std::exception& e) {
66045       {
66046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66047       };
66048     } catch (...) {
66049       {
66050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66051       };
66052     }
66053   }
66054 }
66055
66056
66057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
66058   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66059   float arg2 ;
66060
66061   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66062   arg2 = (float)jarg2;
66063   {
66064     try {
66065       (arg1)->SetMinimumSwipeSpeed(arg2);
66066     } catch (std::out_of_range& e) {
66067       {
66068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66069       };
66070     } catch (std::exception& e) {
66071       {
66072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66073       };
66074     } catch (...) {
66075       {
66076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66077       };
66078     }
66079   }
66080 }
66081
66082
66083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
66084   float jresult ;
66085   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66086   float result;
66087
66088   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66089   {
66090     try {
66091       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
66092     } catch (std::out_of_range& e) {
66093       {
66094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66095       };
66096     } catch (std::exception& e) {
66097       {
66098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66099       };
66100     } catch (...) {
66101       {
66102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66103       };
66104     }
66105   }
66106   jresult = result;
66107   return jresult;
66108 }
66109
66110
66111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
66112   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66113   float arg2 ;
66114
66115   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66116   arg2 = (float)jarg2;
66117   {
66118     try {
66119       (arg1)->SetMinimumSwipeDistance(arg2);
66120     } catch (std::out_of_range& e) {
66121       {
66122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66123       };
66124     } catch (std::exception& e) {
66125       {
66126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66127       };
66128     } catch (...) {
66129       {
66130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66131       };
66132     }
66133   }
66134 }
66135
66136
66137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
66138   float jresult ;
66139   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66140   float result;
66141
66142   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66143   {
66144     try {
66145       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
66146     } catch (std::out_of_range& e) {
66147       {
66148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66149       };
66150     } catch (std::exception& e) {
66151       {
66152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66153       };
66154     } catch (...) {
66155       {
66156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66157       };
66158     }
66159   }
66160   jresult = result;
66161   return jresult;
66162 }
66163
66164
66165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
66166   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66167   float arg2 ;
66168
66169   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66170   arg2 = (float)jarg2;
66171   {
66172     try {
66173       (arg1)->SetWheelScrollDistanceStep(arg2);
66174     } catch (std::out_of_range& e) {
66175       {
66176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66177       };
66178     } catch (std::exception& e) {
66179       {
66180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66181       };
66182     } catch (...) {
66183       {
66184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66185       };
66186     }
66187   }
66188 }
66189
66190
66191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
66192   float jresult ;
66193   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66194   float result;
66195
66196   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66197   {
66198     try {
66199       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
66200     } catch (std::out_of_range& e) {
66201       {
66202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66203       };
66204     } catch (std::exception& e) {
66205       {
66206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66207       };
66208     } catch (...) {
66209       {
66210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66211       };
66212     }
66213   }
66214   jresult = result;
66215   return jresult;
66216 }
66217
66218
66219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
66220   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66221   bool arg2 ;
66222
66223   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66224   arg2 = jarg2 ? true : false;
66225   {
66226     try {
66227       (arg1)->SetAnchoring(arg2);
66228     } catch (std::out_of_range& e) {
66229       {
66230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66231       };
66232     } catch (std::exception& e) {
66233       {
66234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66235       };
66236     } catch (...) {
66237       {
66238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66239       };
66240     }
66241   }
66242 }
66243
66244
66245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
66246   unsigned int jresult ;
66247   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66248   bool result;
66249
66250   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66251   {
66252     try {
66253       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
66254     } catch (std::out_of_range& e) {
66255       {
66256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66257       };
66258     } catch (std::exception& e) {
66259       {
66260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66261       };
66262     } catch (...) {
66263       {
66264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66265       };
66266     }
66267   }
66268   jresult = result;
66269   return jresult;
66270 }
66271
66272
66273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
66274   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66275   float arg2 ;
66276
66277   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66278   arg2 = (float)jarg2;
66279   {
66280     try {
66281       (arg1)->SetAnchoringDuration(arg2);
66282     } catch (std::out_of_range& e) {
66283       {
66284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66285       };
66286     } catch (std::exception& e) {
66287       {
66288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66289       };
66290     } catch (...) {
66291       {
66292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66293       };
66294     }
66295   }
66296 }
66297
66298
66299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
66300   float jresult ;
66301   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66302   float result;
66303
66304   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66305   {
66306     try {
66307       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
66308     } catch (std::out_of_range& e) {
66309       {
66310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66311       };
66312     } catch (std::exception& e) {
66313       {
66314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66315       };
66316     } catch (...) {
66317       {
66318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66319       };
66320     }
66321   }
66322   jresult = result;
66323   return jresult;
66324 }
66325
66326
66327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
66328   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66329   Dali::Toolkit::ItemId arg2 ;
66330   float arg3 ;
66331
66332   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66333   arg2 = (Dali::Toolkit::ItemId)jarg2;
66334   arg3 = (float)jarg3;
66335   {
66336     try {
66337       (arg1)->ScrollToItem(arg2,arg3);
66338     } catch (std::out_of_range& e) {
66339       {
66340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66341       };
66342     } catch (std::exception& e) {
66343       {
66344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66345       };
66346     } catch (...) {
66347       {
66348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66349       };
66350     }
66351   }
66352 }
66353
66354
66355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
66356   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66357   float arg2 ;
66358
66359   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66360   arg2 = (float)jarg2;
66361   {
66362     try {
66363       (arg1)->SetRefreshInterval(arg2);
66364     } catch (std::out_of_range& e) {
66365       {
66366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66367       };
66368     } catch (std::exception& e) {
66369       {
66370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66371       };
66372     } catch (...) {
66373       {
66374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66375       };
66376     }
66377   }
66378 }
66379
66380
66381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
66382   float jresult ;
66383   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66384   float result;
66385
66386   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66387   {
66388     try {
66389       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
66390     } catch (std::out_of_range& e) {
66391       {
66392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66393       };
66394     } catch (std::exception& e) {
66395       {
66396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66397       };
66398     } catch (...) {
66399       {
66400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66401       };
66402     }
66403   }
66404   jresult = result;
66405   return jresult;
66406 }
66407
66408
66409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
66410   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66411
66412   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66413   {
66414     try {
66415       (arg1)->Refresh();
66416     } catch (std::out_of_range& e) {
66417       {
66418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66419       };
66420     } catch (std::exception& e) {
66421       {
66422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66423       };
66424     } catch (...) {
66425       {
66426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66427       };
66428     }
66429   }
66430 }
66431
66432
66433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
66434   void * jresult ;
66435   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66436   Dali::Toolkit::ItemId arg2 ;
66437   Dali::Actor result;
66438
66439   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66440   arg2 = (Dali::Toolkit::ItemId)jarg2;
66441   {
66442     try {
66443       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
66444     } catch (std::out_of_range& e) {
66445       {
66446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66447       };
66448     } catch (std::exception& e) {
66449       {
66450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66451       };
66452     } catch (...) {
66453       {
66454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66455       };
66456     }
66457   }
66458   jresult = new Dali::Actor((const Dali::Actor &)result);
66459   return jresult;
66460 }
66461
66462
66463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
66464   unsigned int jresult ;
66465   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66466   Dali::Actor arg2 ;
66467   Dali::Actor *argp2 ;
66468   Dali::Toolkit::ItemId result;
66469
66470   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66471   argp2 = (Dali::Actor *)jarg2;
66472   if (!argp2) {
66473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66474     return 0;
66475   }
66476   arg2 = *argp2;
66477   {
66478     try {
66479       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
66480     } catch (std::out_of_range& e) {
66481       {
66482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66483       };
66484     } catch (std::exception& e) {
66485       {
66486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66487       };
66488     } catch (...) {
66489       {
66490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66491       };
66492     }
66493   }
66494   jresult = result;
66495   return jresult;
66496 }
66497
66498
66499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
66500   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66501   Dali::Toolkit::Item arg2 ;
66502   float arg3 ;
66503   Dali::Toolkit::Item *argp2 ;
66504
66505   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66506   argp2 = (Dali::Toolkit::Item *)jarg2;
66507   if (!argp2) {
66508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66509     return ;
66510   }
66511   arg2 = *argp2;
66512   arg3 = (float)jarg3;
66513   {
66514     try {
66515       (arg1)->InsertItem(arg2,arg3);
66516     } catch (std::out_of_range& e) {
66517       {
66518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66519       };
66520     } catch (std::exception& e) {
66521       {
66522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66523       };
66524     } catch (...) {
66525       {
66526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66527       };
66528     }
66529   }
66530 }
66531
66532
66533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
66534   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66535   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66536   float arg3 ;
66537
66538   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66539   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66540   if (!arg2) {
66541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66542     return ;
66543   }
66544   arg3 = (float)jarg3;
66545   {
66546     try {
66547       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66548     } catch (std::out_of_range& e) {
66549       {
66550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66551       };
66552     } catch (std::exception& e) {
66553       {
66554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66555       };
66556     } catch (...) {
66557       {
66558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66559       };
66560     }
66561   }
66562 }
66563
66564
66565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
66566   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66567   Dali::Toolkit::ItemId arg2 ;
66568   float arg3 ;
66569
66570   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66571   arg2 = (Dali::Toolkit::ItemId)jarg2;
66572   arg3 = (float)jarg3;
66573   {
66574     try {
66575       (arg1)->RemoveItem(arg2,arg3);
66576     } catch (std::out_of_range& e) {
66577       {
66578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66579       };
66580     } catch (std::exception& e) {
66581       {
66582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66583       };
66584     } catch (...) {
66585       {
66586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66587       };
66588     }
66589   }
66590 }
66591
66592
66593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
66594   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66595   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
66596   float arg3 ;
66597
66598   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66599   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
66600   if (!arg2) {
66601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
66602     return ;
66603   }
66604   arg3 = (float)jarg3;
66605   {
66606     try {
66607       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
66608     } catch (std::out_of_range& e) {
66609       {
66610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66611       };
66612     } catch (std::exception& e) {
66613       {
66614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66615       };
66616     } catch (...) {
66617       {
66618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66619       };
66620     }
66621   }
66622 }
66623
66624
66625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
66626   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66627   Dali::Toolkit::Item arg2 ;
66628   float arg3 ;
66629   Dali::Toolkit::Item *argp2 ;
66630
66631   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66632   argp2 = (Dali::Toolkit::Item *)jarg2;
66633   if (!argp2) {
66634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66635     return ;
66636   }
66637   arg2 = *argp2;
66638   arg3 = (float)jarg3;
66639   {
66640     try {
66641       (arg1)->ReplaceItem(arg2,arg3);
66642     } catch (std::out_of_range& e) {
66643       {
66644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66645       };
66646     } catch (std::exception& e) {
66647       {
66648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66649       };
66650     } catch (...) {
66651       {
66652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66653       };
66654     }
66655   }
66656 }
66657
66658
66659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
66660   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66661   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66662   float arg3 ;
66663
66664   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66665   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66666   if (!arg2) {
66667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66668     return ;
66669   }
66670   arg3 = (float)jarg3;
66671   {
66672     try {
66673       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66674     } catch (std::out_of_range& e) {
66675       {
66676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66677       };
66678     } catch (std::exception& e) {
66679       {
66680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66681       };
66682     } catch (...) {
66683       {
66684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66685       };
66686     }
66687   }
66688 }
66689
66690
66691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
66692   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66693   Dali::Vector3 *arg2 = 0 ;
66694
66695   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66696   arg2 = (Dali::Vector3 *)jarg2;
66697   if (!arg2) {
66698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66699     return ;
66700   }
66701   {
66702     try {
66703       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
66704     } catch (std::out_of_range& e) {
66705       {
66706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66707       };
66708     } catch (std::exception& e) {
66709       {
66710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66711       };
66712     } catch (...) {
66713       {
66714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66715       };
66716     }
66717   }
66718 }
66719
66720
66721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
66722   void * jresult ;
66723   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66724   Dali::Vector3 result;
66725
66726   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66727   {
66728     try {
66729       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
66730     } catch (std::out_of_range& e) {
66731       {
66732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66733       };
66734     } catch (std::exception& e) {
66735       {
66736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66737       };
66738     } catch (...) {
66739       {
66740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66741       };
66742     }
66743   }
66744   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66745   return jresult;
66746 }
66747
66748
66749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
66750   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66751   Dali::Vector3 *arg2 = 0 ;
66752
66753   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66754   arg2 = (Dali::Vector3 *)jarg2;
66755   if (!arg2) {
66756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66757     return ;
66758   }
66759   {
66760     try {
66761       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
66762     } catch (std::out_of_range& e) {
66763       {
66764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66765       };
66766     } catch (std::exception& e) {
66767       {
66768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66769       };
66770     } catch (...) {
66771       {
66772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66773       };
66774     }
66775   }
66776 }
66777
66778
66779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
66780   void * jresult ;
66781   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66782   Dali::Vector3 result;
66783
66784   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66785   {
66786     try {
66787       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
66788     } catch (std::out_of_range& e) {
66789       {
66790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66791       };
66792     } catch (std::exception& e) {
66793       {
66794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66795       };
66796     } catch (...) {
66797       {
66798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66799       };
66800     }
66801   }
66802   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66803   return jresult;
66804 }
66805
66806
66807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
66808   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66809   Dali::Toolkit::ItemRange *arg2 = 0 ;
66810
66811   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66812   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66813   if (!arg2) {
66814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
66815     return ;
66816   }
66817   {
66818     try {
66819       (arg1)->GetItemsRange(*arg2);
66820     } catch (std::out_of_range& e) {
66821       {
66822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66823       };
66824     } catch (std::exception& e) {
66825       {
66826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66827       };
66828     } catch (...) {
66829       {
66830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66831       };
66832     }
66833   }
66834 }
66835
66836
66837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
66838   void * jresult ;
66839   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66840   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
66841
66842   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66843   {
66844     try {
66845       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
66846     } catch (std::out_of_range& e) {
66847       {
66848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66849       };
66850     } catch (std::exception& e) {
66851       {
66852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66853       };
66854     } catch (...) {
66855       {
66856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66857       };
66858     }
66859   }
66860   jresult = (void *)result;
66861   return jresult;
66862 }
66863
66864
66865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
66866   Dali::Vector3 *arg1 = 0 ;
66867   PropertyInputContainer *arg2 = 0 ;
66868
66869   arg1 = (Dali::Vector3 *)jarg1;
66870   if (!arg1) {
66871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66872     return ;
66873   }
66874   arg2 = (PropertyInputContainer *)jarg2;
66875   if (!arg2) {
66876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66877     return ;
66878   }
66879   {
66880     try {
66881       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66882     } catch (std::out_of_range& e) {
66883       {
66884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66885       };
66886     } catch (std::exception& e) {
66887       {
66888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66889       };
66890     } catch (...) {
66891       {
66892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66893       };
66894     }
66895   }
66896 }
66897
66898
66899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
66900   Dali::Vector3 *arg1 = 0 ;
66901   PropertyInputContainer *arg2 = 0 ;
66902
66903   arg1 = (Dali::Vector3 *)jarg1;
66904   if (!arg1) {
66905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66906     return ;
66907   }
66908   arg2 = (PropertyInputContainer *)jarg2;
66909   if (!arg2) {
66910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
66911     return ;
66912   }
66913   {
66914     try {
66915       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
66916     } catch (std::out_of_range& e) {
66917       {
66918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66919       };
66920     } catch (std::exception& e) {
66921       {
66922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66923       };
66924     } catch (...) {
66925       {
66926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66927       };
66928     }
66929   }
66930 }
66931
66932
66933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
66934   void * jresult ;
66935   Dali::Toolkit::ScrollViewEffect *result = 0 ;
66936
66937   {
66938     try {
66939       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
66940     } catch (std::out_of_range& e) {
66941       {
66942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66943       };
66944     } catch (std::exception& e) {
66945       {
66946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66947       };
66948     } catch (...) {
66949       {
66950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66951       };
66952     }
66953   }
66954   jresult = (void *)result;
66955   return jresult;
66956 }
66957
66958
66959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
66960   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
66961
66962   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
66963   {
66964     try {
66965       delete arg1;
66966     } catch (std::out_of_range& e) {
66967       {
66968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66969       };
66970     } catch (std::exception& e) {
66971       {
66972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66973       };
66974     } catch (...) {
66975       {
66976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66977       };
66978     }
66979   }
66980 }
66981
66982
66983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
66984   void * jresult ;
66985   Dali::Path arg1 ;
66986   Dali::Vector3 *arg2 = 0 ;
66987   Dali::Property::Index arg3 ;
66988   Dali::Vector3 *arg4 = 0 ;
66989   unsigned int arg5 ;
66990   Dali::Path *argp1 ;
66991   Dali::Toolkit::ScrollViewPagePathEffect result;
66992
66993   argp1 = (Dali::Path *)jarg1;
66994   if (!argp1) {
66995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
66996     return 0;
66997   }
66998   arg1 = *argp1;
66999   arg2 = (Dali::Vector3 *)jarg2;
67000   if (!arg2) {
67001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67002     return 0;
67003   }
67004   arg3 = (Dali::Property::Index)jarg3;
67005   arg4 = (Dali::Vector3 *)jarg4;
67006   if (!arg4) {
67007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67008     return 0;
67009   }
67010   arg5 = (unsigned int)jarg5;
67011   {
67012     try {
67013       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
67014     } catch (std::out_of_range& e) {
67015       {
67016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67017       };
67018     } catch (std::exception& e) {
67019       {
67020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67021       };
67022     } catch (...) {
67023       {
67024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67025       };
67026     }
67027   }
67028   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67029   return jresult;
67030 }
67031
67032
67033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
67034   void * jresult ;
67035   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
67036
67037   {
67038     try {
67039       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
67040     } catch (std::out_of_range& e) {
67041       {
67042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67043       };
67044     } catch (std::exception& e) {
67045       {
67046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67047       };
67048     } catch (...) {
67049       {
67050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67051       };
67052     }
67053   }
67054   jresult = (void *)result;
67055   return jresult;
67056 }
67057
67058
67059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
67060   void * jresult ;
67061   Dali::BaseHandle arg1 ;
67062   Dali::BaseHandle *argp1 ;
67063   Dali::Toolkit::ScrollViewPagePathEffect result;
67064
67065   argp1 = (Dali::BaseHandle *)jarg1;
67066   if (!argp1) {
67067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67068     return 0;
67069   }
67070   arg1 = *argp1;
67071   {
67072     try {
67073       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
67074     } catch (std::out_of_range& e) {
67075       {
67076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67077       };
67078     } catch (std::exception& e) {
67079       {
67080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67081       };
67082     } catch (...) {
67083       {
67084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67085       };
67086     }
67087   }
67088   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67089   return jresult;
67090 }
67091
67092
67093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
67094   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67095   Dali::Actor arg2 ;
67096   unsigned int arg3 ;
67097   Dali::Actor *argp2 ;
67098
67099   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67100   argp2 = (Dali::Actor *)jarg2;
67101   if (!argp2) {
67102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67103     return ;
67104   }
67105   arg2 = *argp2;
67106   arg3 = (unsigned int)jarg3;
67107   {
67108     try {
67109       (arg1)->ApplyToPage(arg2,arg3);
67110     } catch (std::out_of_range& e) {
67111       {
67112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67113       };
67114     } catch (std::exception& e) {
67115       {
67116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67117       };
67118     } catch (...) {
67119       {
67120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67121       };
67122     }
67123   }
67124 }
67125
67126
67127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
67128   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67129
67130   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67131   {
67132     try {
67133       delete arg1;
67134     } catch (std::out_of_range& e) {
67135       {
67136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67137       };
67138     } catch (std::exception& e) {
67139       {
67140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67141       };
67142     } catch (...) {
67143       {
67144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67145       };
67146     }
67147   }
67148 }
67149
67150
67151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
67152   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67153   Dali::Toolkit::ClampState arg2 ;
67154
67155   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67156   arg2 = (Dali::Toolkit::ClampState)jarg2;
67157   if (arg1) (arg1)->x = arg2;
67158 }
67159
67160
67161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
67162   int jresult ;
67163   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67164   Dali::Toolkit::ClampState result;
67165
67166   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67167   result = (Dali::Toolkit::ClampState) ((arg1)->x);
67168   jresult = (int)result;
67169   return jresult;
67170 }
67171
67172
67173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
67174   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67175   Dali::Toolkit::ClampState arg2 ;
67176
67177   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67178   arg2 = (Dali::Toolkit::ClampState)jarg2;
67179   if (arg1) (arg1)->y = arg2;
67180 }
67181
67182
67183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
67184   int jresult ;
67185   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67186   Dali::Toolkit::ClampState result;
67187
67188   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67189   result = (Dali::Toolkit::ClampState) ((arg1)->y);
67190   jresult = (int)result;
67191   return jresult;
67192 }
67193
67194
67195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
67196   void * jresult ;
67197   Dali::Toolkit::ClampState2D *result = 0 ;
67198
67199   {
67200     try {
67201       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
67202     } catch (std::out_of_range& e) {
67203       {
67204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67205       };
67206     } catch (std::exception& e) {
67207       {
67208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67209       };
67210     } catch (...) {
67211       {
67212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67213       };
67214     }
67215   }
67216   jresult = (void *)result;
67217   return jresult;
67218 }
67219
67220
67221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
67222   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67223
67224   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67225   {
67226     try {
67227       delete arg1;
67228     } catch (std::out_of_range& e) {
67229       {
67230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67231       };
67232     } catch (std::exception& e) {
67233       {
67234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67235       };
67236     } catch (...) {
67237       {
67238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67239       };
67240     }
67241   }
67242 }
67243
67244
67245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
67246   void * jresult ;
67247   float arg1 ;
67248   float arg2 ;
67249   bool arg3 ;
67250   Dali::Toolkit::RulerDomain *result = 0 ;
67251
67252   arg1 = (float)jarg1;
67253   arg2 = (float)jarg2;
67254   arg3 = jarg3 ? true : false;
67255   {
67256     try {
67257       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
67258     } catch (std::out_of_range& e) {
67259       {
67260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67261       };
67262     } catch (std::exception& e) {
67263       {
67264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67265       };
67266     } catch (...) {
67267       {
67268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67269       };
67270     }
67271   }
67272   jresult = (void *)result;
67273   return jresult;
67274 }
67275
67276
67277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
67278   void * jresult ;
67279   float arg1 ;
67280   float arg2 ;
67281   Dali::Toolkit::RulerDomain *result = 0 ;
67282
67283   arg1 = (float)jarg1;
67284   arg2 = (float)jarg2;
67285   {
67286     try {
67287       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
67288     } catch (std::out_of_range& e) {
67289       {
67290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67291       };
67292     } catch (std::exception& e) {
67293       {
67294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67295       };
67296     } catch (...) {
67297       {
67298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67299       };
67300     }
67301   }
67302   jresult = (void *)result;
67303   return jresult;
67304 }
67305
67306
67307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
67308   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67309   float arg2 ;
67310
67311   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67312   arg2 = (float)jarg2;
67313   if (arg1) (arg1)->min = arg2;
67314 }
67315
67316
67317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
67318   float jresult ;
67319   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67320   float result;
67321
67322   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67323   result = (float) ((arg1)->min);
67324   jresult = result;
67325   return jresult;
67326 }
67327
67328
67329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
67330   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67331   float arg2 ;
67332
67333   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67334   arg2 = (float)jarg2;
67335   if (arg1) (arg1)->max = arg2;
67336 }
67337
67338
67339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
67340   float jresult ;
67341   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67342   float result;
67343
67344   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67345   result = (float) ((arg1)->max);
67346   jresult = result;
67347   return jresult;
67348 }
67349
67350
67351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
67352   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67353   bool arg2 ;
67354
67355   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67356   arg2 = jarg2 ? true : false;
67357   if (arg1) (arg1)->enabled = arg2;
67358 }
67359
67360
67361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
67362   unsigned int jresult ;
67363   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67364   bool result;
67365
67366   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67367   result = (bool) ((arg1)->enabled);
67368   jresult = result;
67369   return jresult;
67370 }
67371
67372
67373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67374   float jresult ;
67375   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67376   float arg2 ;
67377   float arg3 ;
67378   float arg4 ;
67379   float result;
67380
67381   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67382   arg2 = (float)jarg2;
67383   arg3 = (float)jarg3;
67384   arg4 = (float)jarg4;
67385   {
67386     try {
67387       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
67388     } catch (std::out_of_range& e) {
67389       {
67390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67391       };
67392     } catch (std::exception& e) {
67393       {
67394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67395       };
67396     } catch (...) {
67397       {
67398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67399       };
67400     }
67401   }
67402   jresult = result;
67403   return jresult;
67404 }
67405
67406
67407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67408   float jresult ;
67409   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67410   float arg2 ;
67411   float arg3 ;
67412   float result;
67413
67414   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67415   arg2 = (float)jarg2;
67416   arg3 = (float)jarg3;
67417   {
67418     try {
67419       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
67420     } catch (std::out_of_range& e) {
67421       {
67422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67423       };
67424     } catch (std::exception& e) {
67425       {
67426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67427       };
67428     } catch (...) {
67429       {
67430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67431       };
67432     }
67433   }
67434   jresult = result;
67435   return jresult;
67436 }
67437
67438
67439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
67440   float jresult ;
67441   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67442   float arg2 ;
67443   float result;
67444
67445   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67446   arg2 = (float)jarg2;
67447   {
67448     try {
67449       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
67450     } catch (std::out_of_range& e) {
67451       {
67452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67453       };
67454     } catch (std::exception& e) {
67455       {
67456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67457       };
67458     } catch (...) {
67459       {
67460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67461       };
67462     }
67463   }
67464   jresult = result;
67465   return jresult;
67466 }
67467
67468
67469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67470   float jresult ;
67471   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67472   float arg2 ;
67473   float arg3 ;
67474   float arg4 ;
67475   Dali::Toolkit::ClampState *arg5 = 0 ;
67476   float result;
67477
67478   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67479   arg2 = (float)jarg2;
67480   arg3 = (float)jarg3;
67481   arg4 = (float)jarg4;
67482   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67483   if (!arg5) {
67484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67485     return 0;
67486   }
67487   {
67488     try {
67489       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67490     } catch (std::out_of_range& e) {
67491       {
67492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67493       };
67494     } catch (std::exception& e) {
67495       {
67496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67497       };
67498     } catch (...) {
67499       {
67500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67501       };
67502     }
67503   }
67504   jresult = result;
67505   return jresult;
67506 }
67507
67508
67509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
67510   float jresult ;
67511   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67512   float result;
67513
67514   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67515   {
67516     try {
67517       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
67518     } catch (std::out_of_range& e) {
67519       {
67520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67521       };
67522     } catch (std::exception& e) {
67523       {
67524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67525       };
67526     } catch (...) {
67527       {
67528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67529       };
67530     }
67531   }
67532   jresult = result;
67533   return jresult;
67534 }
67535
67536
67537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
67538   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67539
67540   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67541   {
67542     try {
67543       delete arg1;
67544     } catch (std::out_of_range& e) {
67545       {
67546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67547       };
67548     } catch (std::exception& e) {
67549       {
67550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67551       };
67552     } catch (...) {
67553       {
67554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67555       };
67556     }
67557   }
67558 }
67559
67560
67561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
67562   float jresult ;
67563   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67564   float arg2 ;
67565   float arg3 ;
67566   float result;
67567
67568   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67569   arg2 = (float)jarg2;
67570   arg3 = (float)jarg3;
67571   {
67572     try {
67573       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
67574     } catch (std::out_of_range& e) {
67575       {
67576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67577       };
67578     } catch (std::exception& e) {
67579       {
67580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67581       };
67582     } catch (...) {
67583       {
67584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67585       };
67586     }
67587   }
67588   jresult = result;
67589   return jresult;
67590 }
67591
67592
67593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
67594   float jresult ;
67595   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67596   float arg2 ;
67597   float result;
67598
67599   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67600   arg2 = (float)jarg2;
67601   {
67602     try {
67603       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
67604     } catch (std::out_of_range& e) {
67605       {
67606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67607       };
67608     } catch (std::exception& e) {
67609       {
67610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67611       };
67612     } catch (...) {
67613       {
67614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67615       };
67616     }
67617   }
67618   jresult = result;
67619   return jresult;
67620 }
67621
67622
67623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
67624   float jresult ;
67625   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67626   unsigned int arg2 ;
67627   unsigned int *arg3 = 0 ;
67628   bool arg4 ;
67629   float result;
67630
67631   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67632   arg2 = (unsigned int)jarg2;
67633   arg3 = (unsigned int *)jarg3;
67634   arg4 = jarg4 ? true : false;
67635   {
67636     try {
67637       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
67638     } catch (std::out_of_range& e) {
67639       {
67640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67641       };
67642     } catch (std::exception& e) {
67643       {
67644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67645       };
67646     } catch (...) {
67647       {
67648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67649       };
67650     }
67651   }
67652   jresult = result;
67653   return jresult;
67654 }
67655
67656
67657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
67658   unsigned int jresult ;
67659   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67660   float arg2 ;
67661   bool arg3 ;
67662   unsigned int result;
67663
67664   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67665   arg2 = (float)jarg2;
67666   arg3 = jarg3 ? true : false;
67667   {
67668     try {
67669       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
67670     } catch (std::out_of_range& e) {
67671       {
67672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67673       };
67674     } catch (std::exception& e) {
67675       {
67676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67677       };
67678     } catch (...) {
67679       {
67680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67681       };
67682     }
67683   }
67684   jresult = result;
67685   return jresult;
67686 }
67687
67688
67689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
67690   unsigned int jresult ;
67691   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67692   unsigned int result;
67693
67694   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67695   {
67696     try {
67697       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
67698     } catch (std::out_of_range& e) {
67699       {
67700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67701       };
67702     } catch (std::exception& e) {
67703       {
67704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67705       };
67706     } catch (...) {
67707       {
67708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67709       };
67710     }
67711   }
67712   jresult = result;
67713   return jresult;
67714 }
67715
67716
67717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
67718   int jresult ;
67719   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67720   Dali::Toolkit::Ruler::RulerType result;
67721
67722   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67723   {
67724     try {
67725       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
67726     } catch (std::out_of_range& e) {
67727       {
67728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67729       };
67730     } catch (std::exception& e) {
67731       {
67732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67733       };
67734     } catch (...) {
67735       {
67736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67737       };
67738     }
67739   }
67740   jresult = (int)result;
67741   return jresult;
67742 }
67743
67744
67745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
67746   unsigned int jresult ;
67747   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67748   bool result;
67749
67750   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67751   {
67752     try {
67753       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
67754     } catch (std::out_of_range& e) {
67755       {
67756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67757       };
67758     } catch (std::exception& e) {
67759       {
67760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67761       };
67762     } catch (...) {
67763       {
67764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67765       };
67766     }
67767   }
67768   jresult = result;
67769   return jresult;
67770 }
67771
67772
67773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
67774   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67775
67776   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67777   {
67778     try {
67779       (arg1)->Enable();
67780     } catch (std::out_of_range& e) {
67781       {
67782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67783       };
67784     } catch (std::exception& e) {
67785       {
67786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67787       };
67788     } catch (...) {
67789       {
67790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67791       };
67792     }
67793   }
67794 }
67795
67796
67797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
67798   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67799
67800   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67801   {
67802     try {
67803       (arg1)->Disable();
67804     } catch (std::out_of_range& e) {
67805       {
67806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67807       };
67808     } catch (std::exception& e) {
67809       {
67810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67811       };
67812     } catch (...) {
67813       {
67814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67815       };
67816     }
67817   }
67818 }
67819
67820
67821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
67822   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67823   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
67824   Dali::Toolkit::RulerDomain *argp2 ;
67825
67826   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67827   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
67828   if (!argp2) {
67829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
67830     return ;
67831   }
67832   arg2 = *argp2;
67833   {
67834     try {
67835       (arg1)->SetDomain(arg2);
67836     } catch (std::out_of_range& e) {
67837       {
67838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67839       };
67840     } catch (std::exception& e) {
67841       {
67842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67843       };
67844     } catch (...) {
67845       {
67846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67847       };
67848     }
67849   }
67850 }
67851
67852
67853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
67854   void * jresult ;
67855   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67856   Dali::Toolkit::RulerDomain *result = 0 ;
67857
67858   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67859   {
67860     try {
67861       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
67862     } catch (std::out_of_range& e) {
67863       {
67864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67865       };
67866     } catch (std::exception& e) {
67867       {
67868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67869       };
67870     } catch (...) {
67871       {
67872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67873       };
67874     }
67875   }
67876   jresult = (void *)result;
67877   return jresult;
67878 }
67879
67880
67881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
67882   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67883
67884   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67885   {
67886     try {
67887       (arg1)->DisableDomain();
67888     } catch (std::out_of_range& e) {
67889       {
67890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67891       };
67892     } catch (std::exception& e) {
67893       {
67894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67895       };
67896     } catch (...) {
67897       {
67898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67899       };
67900     }
67901   }
67902 }
67903
67904
67905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67906   float jresult ;
67907   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67908   float arg2 ;
67909   float arg3 ;
67910   float arg4 ;
67911   float result;
67912
67913   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67914   arg2 = (float)jarg2;
67915   arg3 = (float)jarg3;
67916   arg4 = (float)jarg4;
67917   {
67918     try {
67919       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
67920     } catch (std::out_of_range& e) {
67921       {
67922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67923       };
67924     } catch (std::exception& e) {
67925       {
67926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67927       };
67928     } catch (...) {
67929       {
67930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67931       };
67932     }
67933   }
67934   jresult = result;
67935   return jresult;
67936 }
67937
67938
67939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67940   float jresult ;
67941   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67942   float arg2 ;
67943   float arg3 ;
67944   float result;
67945
67946   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67947   arg2 = (float)jarg2;
67948   arg3 = (float)jarg3;
67949   {
67950     try {
67951       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
67952     } catch (std::out_of_range& e) {
67953       {
67954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67955       };
67956     } catch (std::exception& e) {
67957       {
67958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67959       };
67960     } catch (...) {
67961       {
67962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67963       };
67964     }
67965   }
67966   jresult = result;
67967   return jresult;
67968 }
67969
67970
67971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
67972   float jresult ;
67973   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67974   float arg2 ;
67975   float result;
67976
67977   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67978   arg2 = (float)jarg2;
67979   {
67980     try {
67981       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
67982     } catch (std::out_of_range& e) {
67983       {
67984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67985       };
67986     } catch (std::exception& e) {
67987       {
67988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67989       };
67990     } catch (...) {
67991       {
67992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67993       };
67994     }
67995   }
67996   jresult = result;
67997   return jresult;
67998 }
67999
68000
68001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
68002   float jresult ;
68003   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68004   float arg2 ;
68005   float arg3 ;
68006   float arg4 ;
68007   Dali::Toolkit::ClampState *arg5 = 0 ;
68008   float result;
68009
68010   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68011   arg2 = (float)jarg2;
68012   arg3 = (float)jarg3;
68013   arg4 = (float)jarg4;
68014   arg5 = (Dali::Toolkit::ClampState *)jarg5;
68015   if (!arg5) {
68016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68017     return 0;
68018   }
68019   {
68020     try {
68021       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
68022     } catch (std::out_of_range& e) {
68023       {
68024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68025       };
68026     } catch (std::exception& e) {
68027       {
68028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68029       };
68030     } catch (...) {
68031       {
68032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68033       };
68034     }
68035   }
68036   jresult = result;
68037   return jresult;
68038 }
68039
68040
68041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
68042   float jresult ;
68043   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68044   float arg2 ;
68045   float arg3 ;
68046   float arg4 ;
68047   float arg5 ;
68048   float result;
68049
68050   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68051   arg2 = (float)jarg2;
68052   arg3 = (float)jarg3;
68053   arg4 = (float)jarg4;
68054   arg5 = (float)jarg5;
68055   {
68056     try {
68057       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
68058     } catch (std::out_of_range& e) {
68059       {
68060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68061       };
68062     } catch (std::exception& e) {
68063       {
68064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68065       };
68066     } catch (...) {
68067       {
68068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68069       };
68070     }
68071   }
68072   jresult = result;
68073   return jresult;
68074 }
68075
68076
68077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
68078   float jresult ;
68079   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68080   float arg2 ;
68081   float arg3 ;
68082   float arg4 ;
68083   float result;
68084
68085   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68086   arg2 = (float)jarg2;
68087   arg3 = (float)jarg3;
68088   arg4 = (float)jarg4;
68089   {
68090     try {
68091       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
68092     } catch (std::out_of_range& e) {
68093       {
68094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68095       };
68096     } catch (std::exception& e) {
68097       {
68098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68099       };
68100     } catch (...) {
68101       {
68102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68103       };
68104     }
68105   }
68106   jresult = result;
68107   return jresult;
68108 }
68109
68110
68111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
68112   float jresult ;
68113   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68114   float arg2 ;
68115   float arg3 ;
68116   float result;
68117
68118   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68119   arg2 = (float)jarg2;
68120   arg3 = (float)jarg3;
68121   {
68122     try {
68123       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
68124     } catch (std::out_of_range& e) {
68125       {
68126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68127       };
68128     } catch (std::exception& e) {
68129       {
68130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68131       };
68132     } catch (...) {
68133       {
68134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68135       };
68136     }
68137   }
68138   jresult = result;
68139   return jresult;
68140 }
68141
68142
68143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
68144   float jresult ;
68145   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68146   float arg2 ;
68147   float result;
68148
68149   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68150   arg2 = (float)jarg2;
68151   {
68152     try {
68153       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
68154     } catch (std::out_of_range& e) {
68155       {
68156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68157       };
68158     } catch (std::exception& e) {
68159       {
68160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68161       };
68162     } catch (...) {
68163       {
68164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68165       };
68166     }
68167   }
68168   jresult = result;
68169   return jresult;
68170 }
68171
68172
68173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
68174   float jresult ;
68175   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68176   float arg2 ;
68177   float arg3 ;
68178   float arg4 ;
68179   float arg5 ;
68180   Dali::Toolkit::ClampState *arg6 = 0 ;
68181   float result;
68182
68183   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68184   arg2 = (float)jarg2;
68185   arg3 = (float)jarg3;
68186   arg4 = (float)jarg4;
68187   arg5 = (float)jarg5;
68188   arg6 = (Dali::Toolkit::ClampState *)jarg6;
68189   if (!arg6) {
68190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68191     return 0;
68192   }
68193   {
68194     try {
68195       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
68196     } catch (std::out_of_range& e) {
68197       {
68198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68199       };
68200     } catch (std::exception& e) {
68201       {
68202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68203       };
68204     } catch (...) {
68205       {
68206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68207       };
68208     }
68209   }
68210   jresult = result;
68211   return jresult;
68212 }
68213
68214
68215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
68216   void * jresult ;
68217   Dali::Toolkit::DefaultRuler *result = 0 ;
68218
68219   {
68220     try {
68221       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
68222     } catch (std::out_of_range& e) {
68223       {
68224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68225       };
68226     } catch (std::exception& e) {
68227       {
68228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68229       };
68230     } catch (...) {
68231       {
68232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68233       };
68234     }
68235   }
68236   jresult = (void *)result;
68237   return jresult;
68238 }
68239
68240
68241 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68242   float jresult ;
68243   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68244   float arg2 ;
68245   float arg3 ;
68246   float result;
68247
68248   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68249   arg2 = (float)jarg2;
68250   arg3 = (float)jarg3;
68251   {
68252     try {
68253       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
68254     } catch (std::out_of_range& e) {
68255       {
68256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68257       };
68258     } catch (std::exception& e) {
68259       {
68260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68261       };
68262     } catch (...) {
68263       {
68264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68265       };
68266     }
68267   }
68268   jresult = result;
68269   return jresult;
68270 }
68271
68272
68273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68274   float jresult ;
68275   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68276   unsigned int arg2 ;
68277   unsigned int *arg3 = 0 ;
68278   bool arg4 ;
68279   float result;
68280
68281   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68282   arg2 = (unsigned int)jarg2;
68283   arg3 = (unsigned int *)jarg3;
68284   arg4 = jarg4 ? true : false;
68285   {
68286     try {
68287       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68288     } catch (std::out_of_range& e) {
68289       {
68290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68291       };
68292     } catch (std::exception& e) {
68293       {
68294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68295       };
68296     } catch (...) {
68297       {
68298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68299       };
68300     }
68301   }
68302   jresult = result;
68303   return jresult;
68304 }
68305
68306
68307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68308   unsigned int jresult ;
68309   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68310   float arg2 ;
68311   bool arg3 ;
68312   unsigned int result;
68313
68314   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68315   arg2 = (float)jarg2;
68316   arg3 = jarg3 ? true : false;
68317   {
68318     try {
68319       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68320     } catch (std::out_of_range& e) {
68321       {
68322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68323       };
68324     } catch (std::exception& e) {
68325       {
68326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68327       };
68328     } catch (...) {
68329       {
68330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68331       };
68332     }
68333   }
68334   jresult = result;
68335   return jresult;
68336 }
68337
68338
68339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
68340   unsigned int jresult ;
68341   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68342   unsigned int result;
68343
68344   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68345   {
68346     try {
68347       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
68348     } catch (std::out_of_range& e) {
68349       {
68350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68351       };
68352     } catch (std::exception& e) {
68353       {
68354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68355       };
68356     } catch (...) {
68357       {
68358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68359       };
68360     }
68361   }
68362   jresult = result;
68363   return jresult;
68364 }
68365
68366
68367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
68368   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68369
68370   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68371   {
68372     try {
68373       delete arg1;
68374     } catch (std::out_of_range& e) {
68375       {
68376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68377       };
68378     } catch (std::exception& e) {
68379       {
68380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68381       };
68382     } catch (...) {
68383       {
68384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68385       };
68386     }
68387   }
68388 }
68389
68390
68391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
68392   void * jresult ;
68393   float arg1 ;
68394   Dali::Toolkit::FixedRuler *result = 0 ;
68395
68396   arg1 = (float)jarg1;
68397   {
68398     try {
68399       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
68400     } catch (std::out_of_range& e) {
68401       {
68402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68403       };
68404     } catch (std::exception& e) {
68405       {
68406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68407       };
68408     } catch (...) {
68409       {
68410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68411       };
68412     }
68413   }
68414   jresult = (void *)result;
68415   return jresult;
68416 }
68417
68418
68419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
68420   void * jresult ;
68421   Dali::Toolkit::FixedRuler *result = 0 ;
68422
68423   {
68424     try {
68425       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
68426     } catch (std::out_of_range& e) {
68427       {
68428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68429       };
68430     } catch (std::exception& e) {
68431       {
68432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68433       };
68434     } catch (...) {
68435       {
68436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68437       };
68438     }
68439   }
68440   jresult = (void *)result;
68441   return jresult;
68442 }
68443
68444
68445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68446   float jresult ;
68447   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68448   float arg2 ;
68449   float arg3 ;
68450   float result;
68451
68452   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68453   arg2 = (float)jarg2;
68454   arg3 = (float)jarg3;
68455   {
68456     try {
68457       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
68458     } catch (std::out_of_range& e) {
68459       {
68460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68461       };
68462     } catch (std::exception& e) {
68463       {
68464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68465       };
68466     } catch (...) {
68467       {
68468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68469       };
68470     }
68471   }
68472   jresult = result;
68473   return jresult;
68474 }
68475
68476
68477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68478   float jresult ;
68479   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68480   unsigned int arg2 ;
68481   unsigned int *arg3 = 0 ;
68482   bool arg4 ;
68483   float result;
68484
68485   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68486   arg2 = (unsigned int)jarg2;
68487   arg3 = (unsigned int *)jarg3;
68488   arg4 = jarg4 ? true : false;
68489   {
68490     try {
68491       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68492     } catch (std::out_of_range& e) {
68493       {
68494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68495       };
68496     } catch (std::exception& e) {
68497       {
68498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68499       };
68500     } catch (...) {
68501       {
68502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68503       };
68504     }
68505   }
68506   jresult = result;
68507   return jresult;
68508 }
68509
68510
68511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68512   unsigned int jresult ;
68513   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68514   float arg2 ;
68515   bool arg3 ;
68516   unsigned int result;
68517
68518   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68519   arg2 = (float)jarg2;
68520   arg3 = jarg3 ? true : false;
68521   {
68522     try {
68523       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68524     } catch (std::out_of_range& e) {
68525       {
68526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68527       };
68528     } catch (std::exception& e) {
68529       {
68530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68531       };
68532     } catch (...) {
68533       {
68534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68535       };
68536     }
68537   }
68538   jresult = result;
68539   return jresult;
68540 }
68541
68542
68543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
68544   unsigned int jresult ;
68545   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68546   unsigned int result;
68547
68548   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68549   {
68550     try {
68551       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
68552     } catch (std::out_of_range& e) {
68553       {
68554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68555       };
68556     } catch (std::exception& e) {
68557       {
68558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68559       };
68560     } catch (...) {
68561       {
68562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68563       };
68564     }
68565   }
68566   jresult = result;
68567   return jresult;
68568 }
68569
68570
68571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
68572   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68573
68574   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68575   {
68576     try {
68577       delete arg1;
68578     } catch (std::out_of_range& e) {
68579       {
68580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68581       };
68582     } catch (std::exception& e) {
68583       {
68584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68585       };
68586     } catch (...) {
68587       {
68588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68589       };
68590     }
68591   }
68592 }
68593
68594
68595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
68596   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68597   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68598
68599   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68600   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68601   if (arg1) (arg1)->scale = *arg2;
68602 }
68603
68604
68605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
68606   void * jresult ;
68607   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68608   Dali::Toolkit::ClampState2D *result = 0 ;
68609
68610   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68611   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
68612   jresult = (void *)result;
68613   return jresult;
68614 }
68615
68616
68617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
68618   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68619   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68620
68621   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68622   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68623   if (arg1) (arg1)->position = *arg2;
68624 }
68625
68626
68627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
68628   void * jresult ;
68629   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68630   Dali::Toolkit::ClampState2D *result = 0 ;
68631
68632   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68633   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
68634   jresult = (void *)result;
68635   return jresult;
68636 }
68637
68638
68639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
68640   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68641   Dali::Toolkit::ClampState arg2 ;
68642
68643   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68644   arg2 = (Dali::Toolkit::ClampState)jarg2;
68645   if (arg1) (arg1)->rotation = arg2;
68646 }
68647
68648
68649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
68650   int jresult ;
68651   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68652   Dali::Toolkit::ClampState result;
68653
68654   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68655   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
68656   jresult = (int)result;
68657   return jresult;
68658 }
68659
68660
68661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
68662   void * jresult ;
68663   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
68664
68665   {
68666     try {
68667       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
68668     } catch (std::out_of_range& e) {
68669       {
68670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68671       };
68672     } catch (std::exception& e) {
68673       {
68674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68675       };
68676     } catch (...) {
68677       {
68678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68679       };
68680     }
68681   }
68682   jresult = (void *)result;
68683   return jresult;
68684 }
68685
68686
68687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
68688   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68689
68690   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68691   {
68692     try {
68693       delete arg1;
68694     } catch (std::out_of_range& e) {
68695       {
68696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68697       };
68698     } catch (std::exception& e) {
68699       {
68700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68701       };
68702     } catch (...) {
68703       {
68704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68705       };
68706     }
68707   }
68708 }
68709
68710
68711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
68712   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68713   Dali::Toolkit::SnapType arg2 ;
68714
68715   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68716   arg2 = (Dali::Toolkit::SnapType)jarg2;
68717   if (arg1) (arg1)->type = arg2;
68718 }
68719
68720
68721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
68722   int jresult ;
68723   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68724   Dali::Toolkit::SnapType result;
68725
68726   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68727   result = (Dali::Toolkit::SnapType) ((arg1)->type);
68728   jresult = (int)result;
68729   return jresult;
68730 }
68731
68732
68733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
68734   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68735   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
68736
68737   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68738   arg2 = (Dali::Vector2 *)jarg2;
68739   if (arg1) (arg1)->position = *arg2;
68740 }
68741
68742
68743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
68744   void * jresult ;
68745   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68746   Dali::Vector2 *result = 0 ;
68747
68748   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68749   result = (Dali::Vector2 *)& ((arg1)->position);
68750   jresult = (void *)result;
68751   return jresult;
68752 }
68753
68754
68755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
68756   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68757   float arg2 ;
68758
68759   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68760   arg2 = (float)jarg2;
68761   if (arg1) (arg1)->duration = arg2;
68762 }
68763
68764
68765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
68766   float jresult ;
68767   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68768   float result;
68769
68770   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68771   result = (float) ((arg1)->duration);
68772   jresult = result;
68773   return jresult;
68774 }
68775
68776
68777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
68778   void * jresult ;
68779   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
68780
68781   {
68782     try {
68783       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
68784     } catch (std::out_of_range& e) {
68785       {
68786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68787       };
68788     } catch (std::exception& e) {
68789       {
68790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68791       };
68792     } catch (...) {
68793       {
68794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68795       };
68796     }
68797   }
68798   jresult = (void *)result;
68799   return jresult;
68800 }
68801
68802
68803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
68804   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68805
68806   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68807   {
68808     try {
68809       delete arg1;
68810     } catch (std::out_of_range& e) {
68811       {
68812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68813       };
68814     } catch (std::exception& e) {
68815       {
68816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68817       };
68818     } catch (...) {
68819       {
68820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68821       };
68822     }
68823   }
68824 }
68825
68826
68827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
68828   int jresult ;
68829   int result;
68830
68831   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
68832   jresult = (int)result;
68833   return jresult;
68834 }
68835
68836
68837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
68838   int jresult ;
68839   int result;
68840
68841   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
68842   jresult = (int)result;
68843   return jresult;
68844 }
68845
68846
68847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
68848   int jresult ;
68849   int result;
68850
68851   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
68852   jresult = (int)result;
68853   return jresult;
68854 }
68855
68856
68857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
68858   int jresult ;
68859   int result;
68860
68861   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
68862   jresult = (int)result;
68863   return jresult;
68864 }
68865
68866
68867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
68868   int jresult ;
68869   int result;
68870
68871   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
68872   jresult = (int)result;
68873   return jresult;
68874 }
68875
68876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
68877   int jresult ;
68878   int result;
68879
68880   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
68881   jresult = (int)result;
68882   return jresult;
68883 }
68884
68885
68886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
68887   int jresult ;
68888   int result;
68889
68890   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
68891   jresult = (int)result;
68892   return jresult;
68893 }
68894
68895
68896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
68897   int jresult ;
68898   int result;
68899
68900   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
68901   jresult = (int)result;
68902   return jresult;
68903 }
68904
68905
68906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
68907   int jresult ;
68908   int result;
68909
68910   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
68911   jresult = (int)result;
68912   return jresult;
68913 }
68914
68915
68916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
68917   int jresult ;
68918   int result;
68919
68920   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
68921   jresult = (int)result;
68922   return jresult;
68923 }
68924
68925
68926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
68927   int jresult ;
68928   int result;
68929
68930   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
68931   jresult = (int)result;
68932   return jresult;
68933 }
68934
68935
68936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
68937   int jresult ;
68938   int result;
68939
68940   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
68941   jresult = (int)result;
68942   return jresult;
68943 }
68944
68945
68946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
68947   int jresult ;
68948   int result;
68949
68950   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
68951   jresult = (int)result;
68952   return jresult;
68953 }
68954
68955
68956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
68957   int jresult ;
68958   int result;
68959
68960   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
68961   jresult = (int)result;
68962   return jresult;
68963 }
68964
68965
68966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
68967   int jresult ;
68968   int result;
68969
68970   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
68971   jresult = (int)result;
68972   return jresult;
68973 }
68974
68975
68976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
68977   int jresult ;
68978   int result;
68979
68980   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
68981   jresult = (int)result;
68982   return jresult;
68983 }
68984
68985
68986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
68987   int jresult ;
68988   int result;
68989
68990   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
68991   jresult = (int)result;
68992   return jresult;
68993 }
68994
68995
68996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
68997   int jresult ;
68998   int result;
68999
69000   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
69001   jresult = (int)result;
69002   return jresult;
69003 }
69004
69005
69006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
69007   int jresult ;
69008   int result;
69009
69010   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
69011   jresult = (int)result;
69012   return jresult;
69013 }
69014
69015
69016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
69017   int jresult ;
69018   int result;
69019
69020   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
69021   jresult = (int)result;
69022   return jresult;
69023 }
69024
69025
69026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
69027   int jresult ;
69028   int result;
69029
69030   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
69031   jresult = (int)result;
69032   return jresult;
69033 }
69034
69035
69036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
69037   int jresult ;
69038   int result;
69039
69040   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
69041   jresult = (int)result;
69042   return jresult;
69043 }
69044
69045
69046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
69047   int jresult ;
69048   int result;
69049
69050   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
69051   jresult = (int)result;
69052   return jresult;
69053 }
69054
69055
69056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
69057   int jresult ;
69058   int result;
69059
69060   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
69061   jresult = (int)result;
69062   return jresult;
69063 }
69064
69065
69066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
69067   int jresult ;
69068   int result;
69069
69070   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
69071   jresult = (int)result;
69072   return jresult;
69073 }
69074
69075
69076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
69077   int jresult ;
69078   int result;
69079
69080   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
69081   jresult = (int)result;
69082   return jresult;
69083 }
69084
69085
69086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
69087   void * jresult ;
69088   Dali::Toolkit::ScrollView::Property *result = 0 ;
69089
69090   {
69091     try {
69092       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
69093     } catch (std::out_of_range& e) {
69094       {
69095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69096       };
69097     } catch (std::exception& e) {
69098       {
69099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69100       };
69101     } catch (...) {
69102       {
69103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69104       };
69105     }
69106   }
69107   jresult = (void *)result;
69108   return jresult;
69109 }
69110
69111
69112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
69113   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
69114
69115   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
69116   {
69117     try {
69118       delete arg1;
69119     } catch (std::out_of_range& e) {
69120       {
69121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69122       };
69123     } catch (std::exception& e) {
69124       {
69125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69126       };
69127     } catch (...) {
69128       {
69129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69130       };
69131     }
69132   }
69133 }
69134
69135
69136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
69137   void * jresult ;
69138   Dali::Toolkit::ScrollView *result = 0 ;
69139
69140   {
69141     try {
69142       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
69143     } catch (std::out_of_range& e) {
69144       {
69145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69146       };
69147     } catch (std::exception& e) {
69148       {
69149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69150       };
69151     } catch (...) {
69152       {
69153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69154       };
69155     }
69156   }
69157   jresult = (void *)result;
69158   return jresult;
69159 }
69160
69161
69162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
69163   void * jresult ;
69164   Dali::Toolkit::ScrollView *arg1 = 0 ;
69165   Dali::Toolkit::ScrollView *result = 0 ;
69166
69167   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69168   if (!arg1) {
69169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69170     return 0;
69171   }
69172   {
69173     try {
69174       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
69175     } catch (std::out_of_range& e) {
69176       {
69177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69178       };
69179     } catch (std::exception& e) {
69180       {
69181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69182       };
69183     } catch (...) {
69184       {
69185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69186       };
69187     }
69188   }
69189   jresult = (void *)result;
69190   return jresult;
69191 }
69192
69193
69194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
69195   void * jresult ;
69196   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69197   Dali::Toolkit::ScrollView *arg2 = 0 ;
69198   Dali::Toolkit::ScrollView *result = 0 ;
69199
69200   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69201   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
69202   if (!arg2) {
69203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69204     return 0;
69205   }
69206   {
69207     try {
69208       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
69209     } catch (std::out_of_range& e) {
69210       {
69211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69212       };
69213     } catch (std::exception& e) {
69214       {
69215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69216       };
69217     } catch (...) {
69218       {
69219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69220       };
69221     }
69222   }
69223   jresult = (void *)result;
69224   return jresult;
69225 }
69226
69227
69228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
69229   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69230
69231   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69232   {
69233     try {
69234       delete arg1;
69235     } catch (std::out_of_range& e) {
69236       {
69237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69238       };
69239     } catch (std::exception& e) {
69240       {
69241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69242       };
69243     } catch (...) {
69244       {
69245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69246       };
69247     }
69248   }
69249 }
69250
69251
69252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
69253   void * jresult ;
69254   Dali::Toolkit::ScrollView result;
69255
69256   {
69257     try {
69258       result = Dali::Toolkit::ScrollView::New();
69259     } catch (std::out_of_range& e) {
69260       {
69261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69262       };
69263     } catch (std::exception& e) {
69264       {
69265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69266       };
69267     } catch (...) {
69268       {
69269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69270       };
69271     }
69272   }
69273   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69274   return jresult;
69275 }
69276
69277
69278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
69279   void * jresult ;
69280   Dali::BaseHandle arg1 ;
69281   Dali::BaseHandle *argp1 ;
69282   Dali::Toolkit::ScrollView result;
69283
69284   argp1 = (Dali::BaseHandle *)jarg1;
69285   if (!argp1) {
69286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69287     return 0;
69288   }
69289   arg1 = *argp1;
69290   {
69291     try {
69292       result = Dali::Toolkit::ScrollView::DownCast(arg1);
69293     } catch (std::out_of_range& e) {
69294       {
69295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69296       };
69297     } catch (std::exception& e) {
69298       {
69299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69300       };
69301     } catch (...) {
69302       {
69303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69304       };
69305     }
69306   }
69307   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69308   return jresult;
69309 }
69310
69311
69312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
69313   void * jresult ;
69314   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69315   Dali::AlphaFunction result;
69316
69317   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69318   {
69319     try {
69320       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
69321     } catch (std::out_of_range& e) {
69322       {
69323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69324       };
69325     } catch (std::exception& e) {
69326       {
69327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69328       };
69329     } catch (...) {
69330       {
69331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69332       };
69333     }
69334   }
69335   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69336   return jresult;
69337 }
69338
69339
69340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
69341   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69342   Dali::AlphaFunction arg2 ;
69343   Dali::AlphaFunction *argp2 ;
69344
69345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69346   argp2 = (Dali::AlphaFunction *)jarg2;
69347   if (!argp2) {
69348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69349     return ;
69350   }
69351   arg2 = *argp2;
69352   {
69353     try {
69354       (arg1)->SetScrollSnapAlphaFunction(arg2);
69355     } catch (std::out_of_range& e) {
69356       {
69357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69358       };
69359     } catch (std::exception& e) {
69360       {
69361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69362       };
69363     } catch (...) {
69364       {
69365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69366       };
69367     }
69368   }
69369 }
69370
69371
69372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
69373   void * jresult ;
69374   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69375   Dali::AlphaFunction result;
69376
69377   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69378   {
69379     try {
69380       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
69381     } catch (std::out_of_range& e) {
69382       {
69383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69384       };
69385     } catch (std::exception& e) {
69386       {
69387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69388       };
69389     } catch (...) {
69390       {
69391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69392       };
69393     }
69394   }
69395   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69396   return jresult;
69397 }
69398
69399
69400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
69401   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69402   Dali::AlphaFunction arg2 ;
69403   Dali::AlphaFunction *argp2 ;
69404
69405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69406   argp2 = (Dali::AlphaFunction *)jarg2;
69407   if (!argp2) {
69408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69409     return ;
69410   }
69411   arg2 = *argp2;
69412   {
69413     try {
69414       (arg1)->SetScrollFlickAlphaFunction(arg2);
69415     } catch (std::out_of_range& e) {
69416       {
69417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69418       };
69419     } catch (std::exception& e) {
69420       {
69421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69422       };
69423     } catch (...) {
69424       {
69425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69426       };
69427     }
69428   }
69429 }
69430
69431
69432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
69433   float jresult ;
69434   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69435   float result;
69436
69437   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69438   {
69439     try {
69440       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
69441     } catch (std::out_of_range& e) {
69442       {
69443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69444       };
69445     } catch (std::exception& e) {
69446       {
69447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69448       };
69449     } catch (...) {
69450       {
69451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69452       };
69453     }
69454   }
69455   jresult = result;
69456   return jresult;
69457 }
69458
69459
69460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
69461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69462   float arg2 ;
69463
69464   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69465   arg2 = (float)jarg2;
69466   {
69467     try {
69468       (arg1)->SetScrollSnapDuration(arg2);
69469     } catch (std::out_of_range& e) {
69470       {
69471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69472       };
69473     } catch (std::exception& e) {
69474       {
69475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69476       };
69477     } catch (...) {
69478       {
69479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69480       };
69481     }
69482   }
69483 }
69484
69485
69486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
69487   float jresult ;
69488   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69489   float result;
69490
69491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69492   {
69493     try {
69494       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
69495     } catch (std::out_of_range& e) {
69496       {
69497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69498       };
69499     } catch (std::exception& e) {
69500       {
69501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69502       };
69503     } catch (...) {
69504       {
69505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69506       };
69507     }
69508   }
69509   jresult = result;
69510   return jresult;
69511 }
69512
69513
69514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
69515   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69516   float arg2 ;
69517
69518   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69519   arg2 = (float)jarg2;
69520   {
69521     try {
69522       (arg1)->SetScrollFlickDuration(arg2);
69523     } catch (std::out_of_range& e) {
69524       {
69525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69526       };
69527     } catch (std::exception& e) {
69528       {
69529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69530       };
69531     } catch (...) {
69532       {
69533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69534       };
69535     }
69536   }
69537 }
69538
69539
69540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
69541   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69542   Dali::Toolkit::RulerPtr arg2 ;
69543   Dali::Toolkit::RulerPtr *argp2 ;
69544
69545   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69546   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69547   if (!argp2) {
69548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69549     return ;
69550   }
69551   arg2 = *argp2;
69552   {
69553     try {
69554       (arg1)->SetRulerX(arg2);
69555     } catch (std::out_of_range& e) {
69556       {
69557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69558       };
69559     } catch (std::exception& e) {
69560       {
69561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69562       };
69563     } catch (...) {
69564       {
69565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69566       };
69567     }
69568   }
69569 }
69570
69571
69572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
69573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69574   Dali::Toolkit::RulerPtr arg2 ;
69575   Dali::Toolkit::RulerPtr *argp2 ;
69576
69577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69578   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69579   if (!argp2) {
69580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69581     return ;
69582   }
69583   arg2 = *argp2;
69584   {
69585     try {
69586       (arg1)->SetRulerY(arg2);
69587     } catch (std::out_of_range& e) {
69588       {
69589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69590       };
69591     } catch (std::exception& e) {
69592       {
69593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69594       };
69595     } catch (...) {
69596       {
69597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69598       };
69599     }
69600   }
69601 }
69602
69603
69604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
69605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69606   bool arg2 ;
69607
69608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69609   arg2 = jarg2 ? true : false;
69610   {
69611     try {
69612       (arg1)->SetScrollSensitive(arg2);
69613     } catch (std::out_of_range& e) {
69614       {
69615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69616       };
69617     } catch (std::exception& e) {
69618       {
69619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69620       };
69621     } catch (...) {
69622       {
69623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69624       };
69625     }
69626   }
69627 }
69628
69629
69630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
69631   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69632   float arg2 ;
69633   float arg3 ;
69634
69635   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69636   arg2 = (float)jarg2;
69637   arg3 = (float)jarg3;
69638   {
69639     try {
69640       (arg1)->SetMaxOvershoot(arg2,arg3);
69641     } catch (std::out_of_range& e) {
69642       {
69643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69644       };
69645     } catch (std::exception& e) {
69646       {
69647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69648       };
69649     } catch (...) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69652       };
69653     }
69654   }
69655 }
69656
69657
69658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
69659   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69660   Dali::AlphaFunction arg2 ;
69661   Dali::AlphaFunction *argp2 ;
69662
69663   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69664   argp2 = (Dali::AlphaFunction *)jarg2;
69665   if (!argp2) {
69666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69667     return ;
69668   }
69669   arg2 = *argp2;
69670   {
69671     try {
69672       (arg1)->SetSnapOvershootAlphaFunction(arg2);
69673     } catch (std::out_of_range& e) {
69674       {
69675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69676       };
69677     } catch (std::exception& e) {
69678       {
69679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69680       };
69681     } catch (...) {
69682       {
69683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69684       };
69685     }
69686   }
69687 }
69688
69689
69690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
69691   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69692   float arg2 ;
69693
69694   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69695   arg2 = (float)jarg2;
69696   {
69697     try {
69698       (arg1)->SetSnapOvershootDuration(arg2);
69699     } catch (std::out_of_range& e) {
69700       {
69701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69702       };
69703     } catch (std::exception& e) {
69704       {
69705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69706       };
69707     } catch (...) {
69708       {
69709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69710       };
69711     }
69712   }
69713 }
69714
69715
69716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
69717   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69718   bool arg2 ;
69719
69720   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69721   arg2 = jarg2 ? true : false;
69722   {
69723     try {
69724       (arg1)->SetActorAutoSnap(arg2);
69725     } catch (std::out_of_range& e) {
69726       {
69727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69728       };
69729     } catch (std::exception& e) {
69730       {
69731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69732       };
69733     } catch (...) {
69734       {
69735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69736       };
69737     }
69738   }
69739 }
69740
69741
69742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
69743   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69744   bool arg2 ;
69745
69746   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69747   arg2 = jarg2 ? true : false;
69748   {
69749     try {
69750       (arg1)->SetWrapMode(arg2);
69751     } catch (std::out_of_range& e) {
69752       {
69753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69754       };
69755     } catch (std::exception& e) {
69756       {
69757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69758       };
69759     } catch (...) {
69760       {
69761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69762       };
69763     }
69764   }
69765 }
69766
69767
69768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
69769   int jresult ;
69770   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69771   int result;
69772
69773   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69774   {
69775     try {
69776       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
69777     } catch (std::out_of_range& e) {
69778       {
69779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69780       };
69781     } catch (std::exception& e) {
69782       {
69783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69784       };
69785     } catch (...) {
69786       {
69787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69788       };
69789     }
69790   }
69791   jresult = result;
69792   return jresult;
69793 }
69794
69795
69796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
69797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69798   int arg2 ;
69799
69800   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69801   arg2 = (int)jarg2;
69802   {
69803     try {
69804       (arg1)->SetScrollUpdateDistance(arg2);
69805     } catch (std::out_of_range& e) {
69806       {
69807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69808       };
69809     } catch (std::exception& e) {
69810       {
69811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69812       };
69813     } catch (...) {
69814       {
69815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69816       };
69817     }
69818   }
69819 }
69820
69821
69822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
69823   unsigned int jresult ;
69824   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69825   bool result;
69826
69827   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69828   {
69829     try {
69830       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
69831     } catch (std::out_of_range& e) {
69832       {
69833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69834       };
69835     } catch (std::exception& e) {
69836       {
69837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69838       };
69839     } catch (...) {
69840       {
69841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69842       };
69843     }
69844   }
69845   jresult = result;
69846   return jresult;
69847 }
69848
69849
69850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
69851   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69852   bool arg2 ;
69853
69854   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69855   arg2 = jarg2 ? true : false;
69856   {
69857     try {
69858       (arg1)->SetAxisAutoLock(arg2);
69859     } catch (std::out_of_range& e) {
69860       {
69861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69862       };
69863     } catch (std::exception& e) {
69864       {
69865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69866       };
69867     } catch (...) {
69868       {
69869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69870       };
69871     }
69872   }
69873 }
69874
69875
69876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
69877   float jresult ;
69878   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69879   float result;
69880
69881   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69882   {
69883     try {
69884       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
69885     } catch (std::out_of_range& e) {
69886       {
69887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69888       };
69889     } catch (std::exception& e) {
69890       {
69891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69892       };
69893     } catch (...) {
69894       {
69895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69896       };
69897     }
69898   }
69899   jresult = result;
69900   return jresult;
69901 }
69902
69903
69904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
69905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69906   float arg2 ;
69907
69908   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69909   arg2 = (float)jarg2;
69910   {
69911     try {
69912       (arg1)->SetAxisAutoLockGradient(arg2);
69913     } catch (std::out_of_range& e) {
69914       {
69915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69916       };
69917     } catch (std::exception& e) {
69918       {
69919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69920       };
69921     } catch (...) {
69922       {
69923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69924       };
69925     }
69926   }
69927 }
69928
69929
69930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
69931   float jresult ;
69932   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69933   float result;
69934
69935   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69936   {
69937     try {
69938       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
69939     } catch (std::out_of_range& e) {
69940       {
69941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69942       };
69943     } catch (std::exception& e) {
69944       {
69945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69946       };
69947     } catch (...) {
69948       {
69949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69950       };
69951     }
69952   }
69953   jresult = result;
69954   return jresult;
69955 }
69956
69957
69958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
69959   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69960   float arg2 ;
69961
69962   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69963   arg2 = (float)jarg2;
69964   {
69965     try {
69966       (arg1)->SetFrictionCoefficient(arg2);
69967     } catch (std::out_of_range& e) {
69968       {
69969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69970       };
69971     } catch (std::exception& e) {
69972       {
69973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69974       };
69975     } catch (...) {
69976       {
69977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69978       };
69979     }
69980   }
69981 }
69982
69983
69984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
69985   float jresult ;
69986   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69987   float result;
69988
69989   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69990   {
69991     try {
69992       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
69993     } catch (std::out_of_range& e) {
69994       {
69995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69996       };
69997     } catch (std::exception& e) {
69998       {
69999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70000       };
70001     } catch (...) {
70002       {
70003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70004       };
70005     }
70006   }
70007   jresult = result;
70008   return jresult;
70009 }
70010
70011
70012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
70013   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70014   float arg2 ;
70015
70016   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70017   arg2 = (float)jarg2;
70018   {
70019     try {
70020       (arg1)->SetFlickSpeedCoefficient(arg2);
70021     } catch (std::out_of_range& e) {
70022       {
70023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70024       };
70025     } catch (std::exception& e) {
70026       {
70027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70028       };
70029     } catch (...) {
70030       {
70031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70032       };
70033     }
70034   }
70035 }
70036
70037
70038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
70039   void * jresult ;
70040   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70041   Dali::Vector2 result;
70042
70043   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70044   {
70045     try {
70046       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
70047     } catch (std::out_of_range& e) {
70048       {
70049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70050       };
70051     } catch (std::exception& e) {
70052       {
70053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70054       };
70055     } catch (...) {
70056       {
70057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70058       };
70059     }
70060   }
70061   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70062   return jresult;
70063 }
70064
70065
70066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
70067   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70068   Dali::Vector2 *arg2 = 0 ;
70069
70070   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70071   arg2 = (Dali::Vector2 *)jarg2;
70072   if (!arg2) {
70073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70074     return ;
70075   }
70076   {
70077     try {
70078       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
70079     } catch (std::out_of_range& e) {
70080       {
70081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70082       };
70083     } catch (std::exception& e) {
70084       {
70085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70086       };
70087     } catch (...) {
70088       {
70089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70090       };
70091     }
70092   }
70093 }
70094
70095
70096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
70097   float jresult ;
70098   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70099   float result;
70100
70101   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70102   {
70103     try {
70104       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
70105     } catch (std::out_of_range& e) {
70106       {
70107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70108       };
70109     } catch (std::exception& e) {
70110       {
70111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70112       };
70113     } catch (...) {
70114       {
70115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70116       };
70117     }
70118   }
70119   jresult = result;
70120   return jresult;
70121 }
70122
70123
70124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
70125   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70126   float arg2 ;
70127
70128   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70129   arg2 = (float)jarg2;
70130   {
70131     try {
70132       (arg1)->SetMinimumSpeedForFlick(arg2);
70133     } catch (std::out_of_range& e) {
70134       {
70135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70136       };
70137     } catch (std::exception& e) {
70138       {
70139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70140       };
70141     } catch (...) {
70142       {
70143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70144       };
70145     }
70146   }
70147 }
70148
70149
70150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
70151   float jresult ;
70152   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70153   float result;
70154
70155   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70156   {
70157     try {
70158       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
70159     } catch (std::out_of_range& e) {
70160       {
70161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70162       };
70163     } catch (std::exception& e) {
70164       {
70165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70166       };
70167     } catch (...) {
70168       {
70169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70170       };
70171     }
70172   }
70173   jresult = result;
70174   return jresult;
70175 }
70176
70177
70178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
70179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70180   float arg2 ;
70181
70182   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70183   arg2 = (float)jarg2;
70184   {
70185     try {
70186       (arg1)->SetMaxFlickSpeed(arg2);
70187     } catch (std::out_of_range& e) {
70188       {
70189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70190       };
70191     } catch (std::exception& e) {
70192       {
70193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70194       };
70195     } catch (...) {
70196       {
70197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70198       };
70199     }
70200   }
70201 }
70202
70203
70204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
70205   void * jresult ;
70206   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70207   Dali::Vector2 result;
70208
70209   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70210   {
70211     try {
70212       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
70213     } catch (std::out_of_range& e) {
70214       {
70215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70216       };
70217     } catch (std::exception& e) {
70218       {
70219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70220       };
70221     } catch (...) {
70222       {
70223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70224       };
70225     }
70226   }
70227   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70228   return jresult;
70229 }
70230
70231
70232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
70233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70234   Dali::Vector2 arg2 ;
70235   Dali::Vector2 *argp2 ;
70236
70237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70238   argp2 = (Dali::Vector2 *)jarg2;
70239   if (!argp2) {
70240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
70241     return ;
70242   }
70243   arg2 = *argp2;
70244   {
70245     try {
70246       (arg1)->SetWheelScrollDistanceStep(arg2);
70247     } catch (std::out_of_range& e) {
70248       {
70249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70250       };
70251     } catch (std::exception& e) {
70252       {
70253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70254       };
70255     } catch (...) {
70256       {
70257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70258       };
70259     }
70260   }
70261 }
70262
70263
70264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
70265   void * jresult ;
70266   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70267   Dali::Vector2 result;
70268
70269   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70270   {
70271     try {
70272       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
70273     } catch (std::out_of_range& e) {
70274       {
70275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70276       };
70277     } catch (std::exception& e) {
70278       {
70279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70280       };
70281     } catch (...) {
70282       {
70283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70284       };
70285     }
70286   }
70287   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70288   return jresult;
70289 }
70290
70291
70292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
70293   unsigned int jresult ;
70294   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70295   unsigned int result;
70296
70297   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70298   {
70299     try {
70300       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
70301     } catch (std::out_of_range& e) {
70302       {
70303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70304       };
70305     } catch (std::exception& e) {
70306       {
70307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70308       };
70309     } catch (...) {
70310       {
70311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70312       };
70313     }
70314   }
70315   jresult = result;
70316   return jresult;
70317 }
70318
70319
70320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
70321   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70322   Dali::Vector2 *arg2 = 0 ;
70323
70324   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70325   arg2 = (Dali::Vector2 *)jarg2;
70326   if (!arg2) {
70327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70328     return ;
70329   }
70330   {
70331     try {
70332       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
70333     } catch (std::out_of_range& e) {
70334       {
70335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70336       };
70337     } catch (std::exception& e) {
70338       {
70339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70340       };
70341     } catch (...) {
70342       {
70343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70344       };
70345     }
70346   }
70347 }
70348
70349
70350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
70351   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70352   Dali::Vector2 *arg2 = 0 ;
70353   float arg3 ;
70354
70355   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70356   arg2 = (Dali::Vector2 *)jarg2;
70357   if (!arg2) {
70358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70359     return ;
70360   }
70361   arg3 = (float)jarg3;
70362   {
70363     try {
70364       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
70365     } catch (std::out_of_range& e) {
70366       {
70367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70368       };
70369     } catch (std::exception& e) {
70370       {
70371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70372       };
70373     } catch (...) {
70374       {
70375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70376       };
70377     }
70378   }
70379 }
70380
70381
70382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
70383   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70384   Dali::Vector2 *arg2 = 0 ;
70385   float arg3 ;
70386   Dali::AlphaFunction arg4 ;
70387   Dali::AlphaFunction *argp4 ;
70388
70389   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70390   arg2 = (Dali::Vector2 *)jarg2;
70391   if (!arg2) {
70392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70393     return ;
70394   }
70395   arg3 = (float)jarg3;
70396   argp4 = (Dali::AlphaFunction *)jarg4;
70397   if (!argp4) {
70398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70399     return ;
70400   }
70401   arg4 = *argp4;
70402   {
70403     try {
70404       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
70405     } catch (std::out_of_range& e) {
70406       {
70407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70408       };
70409     } catch (std::exception& e) {
70410       {
70411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70412       };
70413     } catch (...) {
70414       {
70415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70416       };
70417     }
70418   }
70419 }
70420
70421
70422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
70423   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70424   Dali::Vector2 *arg2 = 0 ;
70425   float arg3 ;
70426   Dali::Toolkit::DirectionBias arg4 ;
70427   Dali::Toolkit::DirectionBias arg5 ;
70428
70429   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70430   arg2 = (Dali::Vector2 *)jarg2;
70431   if (!arg2) {
70432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70433     return ;
70434   }
70435   arg3 = (float)jarg3;
70436   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70437   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70438   {
70439     try {
70440       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
70441     } catch (std::out_of_range& e) {
70442       {
70443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70444       };
70445     } catch (std::exception& e) {
70446       {
70447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70448       };
70449     } catch (...) {
70450       {
70451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70452       };
70453     }
70454   }
70455 }
70456
70457
70458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
70459   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70460   Dali::Vector2 *arg2 = 0 ;
70461   float arg3 ;
70462   Dali::AlphaFunction arg4 ;
70463   Dali::Toolkit::DirectionBias arg5 ;
70464   Dali::Toolkit::DirectionBias arg6 ;
70465   Dali::AlphaFunction *argp4 ;
70466
70467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70468   arg2 = (Dali::Vector2 *)jarg2;
70469   if (!arg2) {
70470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70471     return ;
70472   }
70473   arg3 = (float)jarg3;
70474   argp4 = (Dali::AlphaFunction *)jarg4;
70475   if (!argp4) {
70476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70477     return ;
70478   }
70479   arg4 = *argp4;
70480   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70481   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
70482   {
70483     try {
70484       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
70485     } catch (std::out_of_range& e) {
70486       {
70487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70488       };
70489     } catch (std::exception& e) {
70490       {
70491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70492       };
70493     } catch (...) {
70494       {
70495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70496       };
70497     }
70498   }
70499 }
70500
70501
70502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
70503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70504   unsigned int arg2 ;
70505
70506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70507   arg2 = (unsigned int)jarg2;
70508   {
70509     try {
70510       (arg1)->ScrollTo(arg2);
70511     } catch (std::out_of_range& e) {
70512       {
70513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70514       };
70515     } catch (std::exception& e) {
70516       {
70517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70518       };
70519     } catch (...) {
70520       {
70521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70522       };
70523     }
70524   }
70525 }
70526
70527
70528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
70529   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70530   unsigned int arg2 ;
70531   float arg3 ;
70532
70533   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70534   arg2 = (unsigned int)jarg2;
70535   arg3 = (float)jarg3;
70536   {
70537     try {
70538       (arg1)->ScrollTo(arg2,arg3);
70539     } catch (std::out_of_range& e) {
70540       {
70541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70542       };
70543     } catch (std::exception& e) {
70544       {
70545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70546       };
70547     } catch (...) {
70548       {
70549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70550       };
70551     }
70552   }
70553 }
70554
70555
70556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
70557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70558   unsigned int arg2 ;
70559   float arg3 ;
70560   Dali::Toolkit::DirectionBias arg4 ;
70561
70562   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70563   arg2 = (unsigned int)jarg2;
70564   arg3 = (float)jarg3;
70565   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70566   {
70567     try {
70568       (arg1)->ScrollTo(arg2,arg3,arg4);
70569     } catch (std::out_of_range& e) {
70570       {
70571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70572       };
70573     } catch (std::exception& e) {
70574       {
70575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70576       };
70577     } catch (...) {
70578       {
70579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70580       };
70581     }
70582   }
70583 }
70584
70585
70586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
70587   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70588   Dali::Actor *arg2 = 0 ;
70589
70590   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70591   arg2 = (Dali::Actor *)jarg2;
70592   if (!arg2) {
70593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70594     return ;
70595   }
70596   {
70597     try {
70598       (arg1)->ScrollTo(*arg2);
70599     } catch (std::out_of_range& e) {
70600       {
70601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70602       };
70603     } catch (std::exception& e) {
70604       {
70605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70606       };
70607     } catch (...) {
70608       {
70609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70610       };
70611     }
70612   }
70613 }
70614
70615
70616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
70617   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70618   Dali::Actor *arg2 = 0 ;
70619   float arg3 ;
70620
70621   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70622   arg2 = (Dali::Actor *)jarg2;
70623   if (!arg2) {
70624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70625     return ;
70626   }
70627   arg3 = (float)jarg3;
70628   {
70629     try {
70630       (arg1)->ScrollTo(*arg2,arg3);
70631     } catch (std::out_of_range& e) {
70632       {
70633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70634       };
70635     } catch (std::exception& e) {
70636       {
70637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70638       };
70639     } catch (...) {
70640       {
70641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70642       };
70643     }
70644   }
70645 }
70646
70647
70648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
70649   unsigned int jresult ;
70650   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70651   bool result;
70652
70653   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70654   {
70655     try {
70656       result = (bool)(arg1)->ScrollToSnapPoint();
70657     } catch (std::out_of_range& e) {
70658       {
70659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70660       };
70661     } catch (std::exception& e) {
70662       {
70663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70664       };
70665     } catch (...) {
70666       {
70667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70668       };
70669     }
70670   }
70671   jresult = result;
70672   return jresult;
70673 }
70674
70675
70676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
70677   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70678   Dali::Constraint arg2 ;
70679   Dali::Constraint *argp2 ;
70680
70681   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70682   argp2 = (Dali::Constraint *)jarg2;
70683   if (!argp2) {
70684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
70685     return ;
70686   }
70687   arg2 = *argp2;
70688   {
70689     try {
70690       (arg1)->ApplyConstraintToChildren(arg2);
70691     } catch (std::out_of_range& e) {
70692       {
70693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70694       };
70695     } catch (std::exception& e) {
70696       {
70697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70698       };
70699     } catch (...) {
70700       {
70701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70702       };
70703     }
70704   }
70705 }
70706
70707
70708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
70709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70710
70711   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70712   {
70713     try {
70714       (arg1)->RemoveConstraintsFromChildren();
70715     } catch (std::out_of_range& e) {
70716       {
70717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70718       };
70719     } catch (std::exception& e) {
70720       {
70721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70722       };
70723     } catch (...) {
70724       {
70725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70726       };
70727     }
70728   }
70729 }
70730
70731
70732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
70733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70734   Dali::Toolkit::ScrollViewEffect arg2 ;
70735   Dali::Toolkit::ScrollViewEffect *argp2 ;
70736
70737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70738   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70739   if (!argp2) {
70740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70741     return ;
70742   }
70743   arg2 = *argp2;
70744   {
70745     try {
70746       (arg1)->ApplyEffect(arg2);
70747     } catch (std::out_of_range& e) {
70748       {
70749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70750       };
70751     } catch (std::exception& e) {
70752       {
70753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70754       };
70755     } catch (...) {
70756       {
70757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70758       };
70759     }
70760   }
70761 }
70762
70763
70764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
70765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70766   Dali::Toolkit::ScrollViewEffect arg2 ;
70767   Dali::Toolkit::ScrollViewEffect *argp2 ;
70768
70769   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70770   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70771   if (!argp2) {
70772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70773     return ;
70774   }
70775   arg2 = *argp2;
70776   {
70777     try {
70778       (arg1)->RemoveEffect(arg2);
70779     } catch (std::out_of_range& e) {
70780       {
70781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70782       };
70783     } catch (std::exception& e) {
70784       {
70785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70786       };
70787     } catch (...) {
70788       {
70789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70790       };
70791     }
70792   }
70793 }
70794
70795
70796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
70797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70798
70799   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70800   {
70801     try {
70802       (arg1)->RemoveAllEffects();
70803     } catch (std::out_of_range& e) {
70804       {
70805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70806       };
70807     } catch (std::exception& e) {
70808       {
70809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70810       };
70811     } catch (...) {
70812       {
70813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70814       };
70815     }
70816   }
70817 }
70818
70819
70820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
70821   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70822   Dali::Actor arg2 ;
70823   Dali::Actor *argp2 ;
70824
70825   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70826   argp2 = (Dali::Actor *)jarg2;
70827   if (!argp2) {
70828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70829     return ;
70830   }
70831   arg2 = *argp2;
70832   {
70833     try {
70834       (arg1)->BindActor(arg2);
70835     } catch (std::out_of_range& e) {
70836       {
70837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70838       };
70839     } catch (std::exception& e) {
70840       {
70841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70842       };
70843     } catch (...) {
70844       {
70845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70846       };
70847     }
70848   }
70849 }
70850
70851
70852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
70853   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70854   Dali::Actor arg2 ;
70855   Dali::Actor *argp2 ;
70856
70857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70858   argp2 = (Dali::Actor *)jarg2;
70859   if (!argp2) {
70860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70861     return ;
70862   }
70863   arg2 = *argp2;
70864   {
70865     try {
70866       (arg1)->UnbindActor(arg2);
70867     } catch (std::out_of_range& e) {
70868       {
70869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70870       };
70871     } catch (std::exception& e) {
70872       {
70873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70874       };
70875     } catch (...) {
70876       {
70877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70878       };
70879     }
70880   }
70881 }
70882
70883
70884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
70885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70886   Dali::Radian arg2 ;
70887   Dali::Radian arg3 ;
70888   Dali::Radian *argp2 ;
70889   Dali::Radian *argp3 ;
70890
70891   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70892   argp2 = (Dali::Radian *)jarg2;
70893   if (!argp2) {
70894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70895     return ;
70896   }
70897   arg2 = *argp2;
70898   argp3 = (Dali::Radian *)jarg3;
70899   if (!argp3) {
70900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70901     return ;
70902   }
70903   arg3 = *argp3;
70904   {
70905     try {
70906       (arg1)->SetScrollingDirection(arg2,arg3);
70907     } catch (std::out_of_range& e) {
70908       {
70909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70910       };
70911     } catch (std::exception& e) {
70912       {
70913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70914       };
70915     } catch (...) {
70916       {
70917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70918       };
70919     }
70920   }
70921 }
70922
70923
70924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
70925   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70926   Dali::Radian arg2 ;
70927   Dali::Radian *argp2 ;
70928
70929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70930   argp2 = (Dali::Radian *)jarg2;
70931   if (!argp2) {
70932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70933     return ;
70934   }
70935   arg2 = *argp2;
70936   {
70937     try {
70938       (arg1)->SetScrollingDirection(arg2);
70939     } catch (std::out_of_range& e) {
70940       {
70941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70942       };
70943     } catch (std::exception& e) {
70944       {
70945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70950       };
70951     }
70952   }
70953 }
70954
70955
70956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
70957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70958   Dali::Radian arg2 ;
70959   Dali::Radian *argp2 ;
70960
70961   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70962   argp2 = (Dali::Radian *)jarg2;
70963   if (!argp2) {
70964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
70965     return ;
70966   }
70967   arg2 = *argp2;
70968   {
70969     try {
70970       (arg1)->RemoveScrollingDirection(arg2);
70971     } catch (std::out_of_range& e) {
70972       {
70973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70974       };
70975     } catch (std::exception& e) {
70976       {
70977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70978       };
70979     } catch (...) {
70980       {
70981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70982       };
70983     }
70984   }
70985 }
70986
70987
70988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
70989   void * jresult ;
70990   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70991   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
70992
70993   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70994   {
70995     try {
70996       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
70997     } catch (std::out_of_range& e) {
70998       {
70999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71000       };
71001     } catch (std::exception& e) {
71002       {
71003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71004       };
71005     } catch (...) {
71006       {
71007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71008       };
71009     }
71010   }
71011   jresult = (void *)result;
71012   return jresult;
71013 }
71014
71015
71016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
71017   int jresult ;
71018   int result;
71019
71020   result = (int)Dali::Toolkit::TableView::Property::ROWS;
71021   jresult = (int)result;
71022   return jresult;
71023 }
71024
71025
71026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
71027   int jresult ;
71028   int result;
71029
71030   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
71031   jresult = (int)result;
71032   return jresult;
71033 }
71034
71035
71036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
71037   int jresult ;
71038   int result;
71039
71040   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
71041   jresult = (int)result;
71042   return jresult;
71043 }
71044
71045
71046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
71047   int jresult ;
71048   int result;
71049
71050   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
71051   jresult = (int)result;
71052   return jresult;
71053 }
71054
71055
71056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
71057   int jresult ;
71058   int result;
71059
71060   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
71061   jresult = (int)result;
71062   return jresult;
71063 }
71064
71065
71066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
71067   void * jresult ;
71068   Dali::Toolkit::TableView::Property *result = 0 ;
71069
71070   {
71071     try {
71072       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
71073     } catch (std::out_of_range& e) {
71074       {
71075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71076       };
71077     } catch (std::exception& e) {
71078       {
71079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71080       };
71081     } catch (...) {
71082       {
71083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71084       };
71085     }
71086   }
71087   jresult = (void *)result;
71088   return jresult;
71089 }
71090
71091
71092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
71093   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
71094
71095   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
71096   {
71097     try {
71098       delete arg1;
71099     } catch (std::out_of_range& e) {
71100       {
71101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71102       };
71103     } catch (std::exception& e) {
71104       {
71105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71106       };
71107     } catch (...) {
71108       {
71109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71110       };
71111     }
71112   }
71113 }
71114
71115
71116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
71117   int jresult ;
71118   int result;
71119
71120   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
71121   jresult = (int)result;
71122   return jresult;
71123 }
71124
71125
71126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
71127   int jresult ;
71128   int result;
71129
71130   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
71131   jresult = (int)result;
71132   return jresult;
71133 }
71134
71135
71136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
71137   int jresult ;
71138   int result;
71139
71140   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
71141   jresult = (int)result;
71142   return jresult;
71143 }
71144
71145
71146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
71147   int jresult ;
71148   int result;
71149
71150   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
71151   jresult = (int)result;
71152   return jresult;
71153 }
71154
71155
71156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
71157   int jresult ;
71158   int result;
71159
71160   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
71161   jresult = (int)result;
71162   return jresult;
71163 }
71164
71165
71166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
71167   void * jresult ;
71168   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
71169
71170   {
71171     try {
71172       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
71173     } catch (std::out_of_range& e) {
71174       {
71175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71176       };
71177     } catch (std::exception& e) {
71178       {
71179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71180       };
71181     } catch (...) {
71182       {
71183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71184       };
71185     }
71186   }
71187   jresult = (void *)result;
71188   return jresult;
71189 }
71190
71191
71192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
71193   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
71194
71195   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
71196   {
71197     try {
71198       delete arg1;
71199     } catch (std::out_of_range& e) {
71200       {
71201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71202       };
71203     } catch (std::exception& e) {
71204       {
71205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71206       };
71207     } catch (...) {
71208       {
71209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71210       };
71211     }
71212   }
71213 }
71214
71215
71216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
71217   void * jresult ;
71218   unsigned int arg1 ;
71219   unsigned int arg2 ;
71220   unsigned int arg3 ;
71221   unsigned int arg4 ;
71222   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71223
71224   arg1 = (unsigned int)jarg1;
71225   arg2 = (unsigned int)jarg2;
71226   arg3 = (unsigned int)jarg3;
71227   arg4 = (unsigned int)jarg4;
71228   {
71229     try {
71230       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
71231     } catch (std::out_of_range& e) {
71232       {
71233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71234       };
71235     } catch (std::exception& e) {
71236       {
71237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71238       };
71239     } catch (...) {
71240       {
71241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71242       };
71243     }
71244   }
71245   jresult = (void *)result;
71246   return jresult;
71247 }
71248
71249
71250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
71251   void * jresult ;
71252   unsigned int arg1 ;
71253   unsigned int arg2 ;
71254   unsigned int arg3 ;
71255   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71256
71257   arg1 = (unsigned int)jarg1;
71258   arg2 = (unsigned int)jarg2;
71259   arg3 = (unsigned int)jarg3;
71260   {
71261     try {
71262       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
71263     } catch (std::out_of_range& e) {
71264       {
71265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71266       };
71267     } catch (std::exception& e) {
71268       {
71269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71270       };
71271     } catch (...) {
71272       {
71273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71274       };
71275     }
71276   }
71277   jresult = (void *)result;
71278   return jresult;
71279 }
71280
71281
71282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
71283   void * jresult ;
71284   unsigned int arg1 ;
71285   unsigned int arg2 ;
71286   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71287
71288   arg1 = (unsigned int)jarg1;
71289   arg2 = (unsigned int)jarg2;
71290   {
71291     try {
71292       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
71293     } catch (std::out_of_range& e) {
71294       {
71295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71296       };
71297     } catch (std::exception& e) {
71298       {
71299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71300       };
71301     } catch (...) {
71302       {
71303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71304       };
71305     }
71306   }
71307   jresult = (void *)result;
71308   return jresult;
71309 }
71310
71311
71312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
71313   void * jresult ;
71314   unsigned int arg1 ;
71315   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71316
71317   arg1 = (unsigned int)jarg1;
71318   {
71319     try {
71320       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
71321     } catch (std::out_of_range& e) {
71322       {
71323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71324       };
71325     } catch (std::exception& e) {
71326       {
71327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71328       };
71329     } catch (...) {
71330       {
71331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71332       };
71333     }
71334   }
71335   jresult = (void *)result;
71336   return jresult;
71337 }
71338
71339
71340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
71341   void * jresult ;
71342   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71343
71344   {
71345     try {
71346       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
71347     } catch (std::out_of_range& e) {
71348       {
71349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71350       };
71351     } catch (std::exception& e) {
71352       {
71353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71354       };
71355     } catch (...) {
71356       {
71357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71358       };
71359     }
71360   }
71361   jresult = (void *)result;
71362   return jresult;
71363 }
71364
71365
71366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
71367   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71368   unsigned int arg2 ;
71369
71370   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71371   arg2 = (unsigned int)jarg2;
71372   if (arg1) (arg1)->rowIndex = arg2;
71373 }
71374
71375
71376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
71377   unsigned int jresult ;
71378   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71379   unsigned int result;
71380
71381   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71382   result = (unsigned int) ((arg1)->rowIndex);
71383   jresult = result;
71384   return jresult;
71385 }
71386
71387
71388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
71389   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71390   unsigned int arg2 ;
71391
71392   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71393   arg2 = (unsigned int)jarg2;
71394   if (arg1) (arg1)->columnIndex = arg2;
71395 }
71396
71397
71398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
71399   unsigned int jresult ;
71400   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71401   unsigned int result;
71402
71403   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71404   result = (unsigned int) ((arg1)->columnIndex);
71405   jresult = result;
71406   return jresult;
71407 }
71408
71409
71410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
71411   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71412   unsigned int arg2 ;
71413
71414   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71415   arg2 = (unsigned int)jarg2;
71416   if (arg1) (arg1)->rowSpan = arg2;
71417 }
71418
71419
71420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
71421   unsigned int jresult ;
71422   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71423   unsigned int result;
71424
71425   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71426   result = (unsigned int) ((arg1)->rowSpan);
71427   jresult = result;
71428   return jresult;
71429 }
71430
71431
71432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
71433   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71434   unsigned int arg2 ;
71435
71436   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71437   arg2 = (unsigned int)jarg2;
71438   if (arg1) (arg1)->columnSpan = arg2;
71439 }
71440
71441
71442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
71443   unsigned int jresult ;
71444   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71445   unsigned int result;
71446
71447   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71448   result = (unsigned int) ((arg1)->columnSpan);
71449   jresult = result;
71450   return jresult;
71451 }
71452
71453
71454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
71455   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71456
71457   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71458   {
71459     try {
71460       delete arg1;
71461     } catch (std::out_of_range& e) {
71462       {
71463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71464       };
71465     } catch (std::exception& e) {
71466       {
71467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71468       };
71469     } catch (...) {
71470       {
71471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71472       };
71473     }
71474   }
71475 }
71476
71477
71478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
71479   void * jresult ;
71480   Dali::Toolkit::TableView *result = 0 ;
71481
71482   {
71483     try {
71484       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
71485     } catch (std::out_of_range& e) {
71486       {
71487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71488       };
71489     } catch (std::exception& e) {
71490       {
71491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71492       };
71493     } catch (...) {
71494       {
71495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71496       };
71497     }
71498   }
71499   jresult = (void *)result;
71500   return jresult;
71501 }
71502
71503
71504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
71505   void * jresult ;
71506   Dali::Toolkit::TableView *arg1 = 0 ;
71507   Dali::Toolkit::TableView *result = 0 ;
71508
71509   arg1 = (Dali::Toolkit::TableView *)jarg1;
71510   if (!arg1) {
71511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71512     return 0;
71513   }
71514   {
71515     try {
71516       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
71517     } catch (std::out_of_range& e) {
71518       {
71519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71520       };
71521     } catch (std::exception& e) {
71522       {
71523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71524       };
71525     } catch (...) {
71526       {
71527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71528       };
71529     }
71530   }
71531   jresult = (void *)result;
71532   return jresult;
71533 }
71534
71535
71536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
71537   void * jresult ;
71538   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71539   Dali::Toolkit::TableView *arg2 = 0 ;
71540   Dali::Toolkit::TableView *result = 0 ;
71541
71542   arg1 = (Dali::Toolkit::TableView *)jarg1;
71543   arg2 = (Dali::Toolkit::TableView *)jarg2;
71544   if (!arg2) {
71545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71546     return 0;
71547   }
71548   {
71549     try {
71550       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
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 = (void *)result;
71566   return jresult;
71567 }
71568
71569
71570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
71571   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71572
71573   arg1 = (Dali::Toolkit::TableView *)jarg1;
71574   {
71575     try {
71576       delete arg1;
71577     } catch (std::out_of_range& e) {
71578       {
71579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71580       };
71581     } catch (std::exception& e) {
71582       {
71583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71584       };
71585     } catch (...) {
71586       {
71587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71588       };
71589     }
71590   }
71591 }
71592
71593
71594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
71595   void * jresult ;
71596   unsigned int arg1 ;
71597   unsigned int arg2 ;
71598   Dali::Toolkit::TableView result;
71599
71600   arg1 = (unsigned int)jarg1;
71601   arg2 = (unsigned int)jarg2;
71602   {
71603     try {
71604       result = Dali::Toolkit::TableView::New(arg1,arg2);
71605     } catch (std::out_of_range& e) {
71606       {
71607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71608       };
71609     } catch (std::exception& e) {
71610       {
71611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71612       };
71613     } catch (...) {
71614       {
71615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71616       };
71617     }
71618   }
71619   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71620   return jresult;
71621 }
71622
71623
71624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
71625   void * jresult ;
71626   Dali::BaseHandle arg1 ;
71627   Dali::BaseHandle *argp1 ;
71628   Dali::Toolkit::TableView result;
71629
71630   argp1 = (Dali::BaseHandle *)jarg1;
71631   if (!argp1) {
71632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71633     return 0;
71634   }
71635   arg1 = *argp1;
71636   {
71637     try {
71638       result = Dali::Toolkit::TableView::DownCast(arg1);
71639     } catch (std::out_of_range& e) {
71640       {
71641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71642       };
71643     } catch (std::exception& e) {
71644       {
71645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71646       };
71647     } catch (...) {
71648       {
71649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71650       };
71651     }
71652   }
71653   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71654   return jresult;
71655 }
71656
71657
71658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
71659   unsigned int jresult ;
71660   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71661   Dali::Actor arg2 ;
71662   Dali::Toolkit::TableView::CellPosition arg3 ;
71663   Dali::Actor *argp2 ;
71664   Dali::Toolkit::TableView::CellPosition *argp3 ;
71665   bool result;
71666
71667   arg1 = (Dali::Toolkit::TableView *)jarg1;
71668   argp2 = (Dali::Actor *)jarg2;
71669   if (!argp2) {
71670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71671     return 0;
71672   }
71673   arg2 = *argp2;
71674   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71675   if (!argp3) {
71676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71677     return 0;
71678   }
71679   arg3 = *argp3;
71680   {
71681     try {
71682       result = (bool)(arg1)->AddChild(arg2,arg3);
71683     } catch (std::out_of_range& e) {
71684       {
71685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71686       };
71687     } catch (std::exception& e) {
71688       {
71689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71690       };
71691     } catch (...) {
71692       {
71693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71694       };
71695     }
71696   }
71697   jresult = result;
71698   return jresult;
71699 }
71700
71701
71702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
71703   void * jresult ;
71704   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71705   Dali::Toolkit::TableView::CellPosition arg2 ;
71706   Dali::Toolkit::TableView::CellPosition *argp2 ;
71707   Dali::Actor result;
71708
71709   arg1 = (Dali::Toolkit::TableView *)jarg1;
71710   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71711   if (!argp2) {
71712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71713     return 0;
71714   }
71715   arg2 = *argp2;
71716   {
71717     try {
71718       result = (arg1)->GetChildAt(arg2);
71719     } catch (std::out_of_range& e) {
71720       {
71721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71722       };
71723     } catch (std::exception& e) {
71724       {
71725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71726       };
71727     } catch (...) {
71728       {
71729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71730       };
71731     }
71732   }
71733   jresult = new Dali::Actor((const Dali::Actor &)result);
71734   return jresult;
71735 }
71736
71737
71738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
71739   void * jresult ;
71740   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71741   Dali::Toolkit::TableView::CellPosition arg2 ;
71742   Dali::Toolkit::TableView::CellPosition *argp2 ;
71743   Dali::Actor result;
71744
71745   arg1 = (Dali::Toolkit::TableView *)jarg1;
71746   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71747   if (!argp2) {
71748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71749     return 0;
71750   }
71751   arg2 = *argp2;
71752   {
71753     try {
71754       result = (arg1)->RemoveChildAt(arg2);
71755     } catch (std::out_of_range& e) {
71756       {
71757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71758       };
71759     } catch (std::exception& e) {
71760       {
71761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71762       };
71763     } catch (...) {
71764       {
71765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71766       };
71767     }
71768   }
71769   jresult = new Dali::Actor((const Dali::Actor &)result);
71770   return jresult;
71771 }
71772
71773
71774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
71775   unsigned int jresult ;
71776   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71777   Dali::Actor arg2 ;
71778   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
71779   Dali::Actor *argp2 ;
71780   bool result;
71781
71782   arg1 = (Dali::Toolkit::TableView *)jarg1;
71783   argp2 = (Dali::Actor *)jarg2;
71784   if (!argp2) {
71785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71786     return 0;
71787   }
71788   arg2 = *argp2;
71789   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71790   if (!arg3) {
71791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
71792     return 0;
71793   }
71794   {
71795     try {
71796       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
71797     } catch (std::out_of_range& e) {
71798       {
71799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71800       };
71801     } catch (std::exception& e) {
71802       {
71803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71804       };
71805     } catch (...) {
71806       {
71807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71808       };
71809     }
71810   }
71811   jresult = result;
71812   return jresult;
71813 }
71814
71815
71816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
71817   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71818   unsigned int arg2 ;
71819
71820   arg1 = (Dali::Toolkit::TableView *)jarg1;
71821   arg2 = (unsigned int)jarg2;
71822   {
71823     try {
71824       (arg1)->InsertRow(arg2);
71825     } catch (std::out_of_range& e) {
71826       {
71827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71828       };
71829     } catch (std::exception& e) {
71830       {
71831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71832       };
71833     } catch (...) {
71834       {
71835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71836       };
71837     }
71838   }
71839 }
71840
71841
71842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
71843   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71844   unsigned int arg2 ;
71845
71846   arg1 = (Dali::Toolkit::TableView *)jarg1;
71847   arg2 = (unsigned int)jarg2;
71848   {
71849     try {
71850       (arg1)->DeleteRow(arg2);
71851     } catch (std::out_of_range& e) {
71852       {
71853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71854       };
71855     } catch (std::exception& e) {
71856       {
71857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71858       };
71859     } catch (...) {
71860       {
71861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71862       };
71863     }
71864   }
71865 }
71866
71867
71868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71869   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71870   unsigned int arg2 ;
71871   std::vector< Dali::Actor > *arg3 = 0 ;
71872
71873   arg1 = (Dali::Toolkit::TableView *)jarg1;
71874   arg2 = (unsigned int)jarg2;
71875   arg3 = (std::vector< Dali::Actor > *)jarg3;
71876   if (!arg3) {
71877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71878     return ;
71879   }
71880   {
71881     try {
71882       (arg1)->DeleteRow(arg2,*arg3);
71883     } catch (std::out_of_range& e) {
71884       {
71885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71886       };
71887     } catch (std::exception& e) {
71888       {
71889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71890       };
71891     } catch (...) {
71892       {
71893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71894       };
71895     }
71896   }
71897 }
71898
71899
71900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
71901   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71902   unsigned int arg2 ;
71903
71904   arg1 = (Dali::Toolkit::TableView *)jarg1;
71905   arg2 = (unsigned int)jarg2;
71906   {
71907     try {
71908       (arg1)->InsertColumn(arg2);
71909     } catch (std::out_of_range& e) {
71910       {
71911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71912       };
71913     } catch (std::exception& e) {
71914       {
71915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71916       };
71917     } catch (...) {
71918       {
71919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71920       };
71921     }
71922   }
71923 }
71924
71925
71926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
71927   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71928   unsigned int arg2 ;
71929
71930   arg1 = (Dali::Toolkit::TableView *)jarg1;
71931   arg2 = (unsigned int)jarg2;
71932   {
71933     try {
71934       (arg1)->DeleteColumn(arg2);
71935     } catch (std::out_of_range& e) {
71936       {
71937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71938       };
71939     } catch (std::exception& e) {
71940       {
71941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71942       };
71943     } catch (...) {
71944       {
71945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71946       };
71947     }
71948   }
71949 }
71950
71951
71952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
71953   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71954   unsigned int arg2 ;
71955   std::vector< Dali::Actor > *arg3 = 0 ;
71956
71957   arg1 = (Dali::Toolkit::TableView *)jarg1;
71958   arg2 = (unsigned int)jarg2;
71959   arg3 = (std::vector< Dali::Actor > *)jarg3;
71960   if (!arg3) {
71961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
71962     return ;
71963   }
71964   {
71965     try {
71966       (arg1)->DeleteColumn(arg2,*arg3);
71967     } catch (std::out_of_range& e) {
71968       {
71969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71970       };
71971     } catch (std::exception& e) {
71972       {
71973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71974       };
71975     } catch (...) {
71976       {
71977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71978       };
71979     }
71980   }
71981 }
71982
71983
71984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
71985   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71986   unsigned int arg2 ;
71987   unsigned int arg3 ;
71988
71989   arg1 = (Dali::Toolkit::TableView *)jarg1;
71990   arg2 = (unsigned int)jarg2;
71991   arg3 = (unsigned int)jarg3;
71992   {
71993     try {
71994       (arg1)->Resize(arg2,arg3);
71995     } catch (std::out_of_range& e) {
71996       {
71997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71998       };
71999     } catch (std::exception& e) {
72000       {
72001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72002       };
72003     } catch (...) {
72004       {
72005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72006       };
72007     }
72008   }
72009 }
72010
72011
72012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
72013   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72014   unsigned int arg2 ;
72015   unsigned int arg3 ;
72016   std::vector< Dali::Actor > *arg4 = 0 ;
72017
72018   arg1 = (Dali::Toolkit::TableView *)jarg1;
72019   arg2 = (unsigned int)jarg2;
72020   arg3 = (unsigned int)jarg3;
72021   arg4 = (std::vector< Dali::Actor > *)jarg4;
72022   if (!arg4) {
72023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72024     return ;
72025   }
72026   {
72027     try {
72028       (arg1)->Resize(arg2,arg3,*arg4);
72029     } catch (std::out_of_range& e) {
72030       {
72031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72032       };
72033     } catch (std::exception& e) {
72034       {
72035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72036       };
72037     } catch (...) {
72038       {
72039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72040       };
72041     }
72042   }
72043 }
72044
72045
72046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
72047   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72048   Dali::Size arg2 ;
72049   Dali::Size *argp2 ;
72050
72051   arg1 = (Dali::Toolkit::TableView *)jarg1;
72052   argp2 = (Dali::Size *)jarg2;
72053   if (!argp2) {
72054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
72055     return ;
72056   }
72057   arg2 = *argp2;
72058   {
72059     try {
72060       (arg1)->SetCellPadding(arg2);
72061     } catch (std::out_of_range& e) {
72062       {
72063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72064       };
72065     } catch (std::exception& e) {
72066       {
72067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72068       };
72069     } catch (...) {
72070       {
72071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72072       };
72073     }
72074   }
72075 }
72076
72077
72078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
72079   void * jresult ;
72080   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72081   Dali::Size result;
72082
72083   arg1 = (Dali::Toolkit::TableView *)jarg1;
72084   {
72085     try {
72086       result = (arg1)->GetCellPadding();
72087     } catch (std::out_of_range& e) {
72088       {
72089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72090       };
72091     } catch (std::exception& e) {
72092       {
72093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72094       };
72095     } catch (...) {
72096       {
72097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72098       };
72099     }
72100   }
72101   jresult = new Dali::Size((const Dali::Size &)result);
72102   return jresult;
72103 }
72104
72105
72106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
72107   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72108   unsigned int arg2 ;
72109
72110   arg1 = (Dali::Toolkit::TableView *)jarg1;
72111   arg2 = (unsigned int)jarg2;
72112   {
72113     try {
72114       (arg1)->SetFitHeight(arg2);
72115     } catch (std::out_of_range& e) {
72116       {
72117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72118       };
72119     } catch (std::exception& e) {
72120       {
72121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72122       };
72123     } catch (...) {
72124       {
72125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72126       };
72127     }
72128   }
72129 }
72130
72131
72132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
72133   unsigned int jresult ;
72134   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72135   unsigned int arg2 ;
72136   bool result;
72137
72138   arg1 = (Dali::Toolkit::TableView *)jarg1;
72139   arg2 = (unsigned int)jarg2;
72140   {
72141     try {
72142       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
72143     } catch (std::out_of_range& e) {
72144       {
72145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72146       };
72147     } catch (std::exception& e) {
72148       {
72149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72150       };
72151     } catch (...) {
72152       {
72153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72154       };
72155     }
72156   }
72157   jresult = result;
72158   return jresult;
72159 }
72160
72161
72162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
72163   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72164   unsigned int arg2 ;
72165
72166   arg1 = (Dali::Toolkit::TableView *)jarg1;
72167   arg2 = (unsigned int)jarg2;
72168   {
72169     try {
72170       (arg1)->SetFitWidth(arg2);
72171     } catch (std::out_of_range& e) {
72172       {
72173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72174       };
72175     } catch (std::exception& e) {
72176       {
72177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72178       };
72179     } catch (...) {
72180       {
72181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72182       };
72183     }
72184   }
72185 }
72186
72187
72188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
72189   unsigned int jresult ;
72190   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72191   unsigned int arg2 ;
72192   bool result;
72193
72194   arg1 = (Dali::Toolkit::TableView *)jarg1;
72195   arg2 = (unsigned int)jarg2;
72196   {
72197     try {
72198       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
72199     } catch (std::out_of_range& e) {
72200       {
72201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72202       };
72203     } catch (std::exception& e) {
72204       {
72205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72206       };
72207     } catch (...) {
72208       {
72209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72210       };
72211     }
72212   }
72213   jresult = result;
72214   return jresult;
72215 }
72216
72217
72218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72219   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72220   unsigned int arg2 ;
72221   float arg3 ;
72222
72223   arg1 = (Dali::Toolkit::TableView *)jarg1;
72224   arg2 = (unsigned int)jarg2;
72225   arg3 = (float)jarg3;
72226   {
72227     try {
72228       (arg1)->SetFixedHeight(arg2,arg3);
72229     } catch (std::out_of_range& e) {
72230       {
72231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72232       };
72233     } catch (std::exception& e) {
72234       {
72235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72236       };
72237     } catch (...) {
72238       {
72239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72240       };
72241     }
72242   }
72243 }
72244
72245
72246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
72247   float jresult ;
72248   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72249   unsigned int arg2 ;
72250   float result;
72251
72252   arg1 = (Dali::Toolkit::TableView *)jarg1;
72253   arg2 = (unsigned int)jarg2;
72254   {
72255     try {
72256       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
72257     } catch (std::out_of_range& e) {
72258       {
72259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72260       };
72261     } catch (std::exception& e) {
72262       {
72263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72264       };
72265     } catch (...) {
72266       {
72267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72268       };
72269     }
72270   }
72271   jresult = result;
72272   return jresult;
72273 }
72274
72275
72276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72277   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72278   unsigned int arg2 ;
72279   float arg3 ;
72280
72281   arg1 = (Dali::Toolkit::TableView *)jarg1;
72282   arg2 = (unsigned int)jarg2;
72283   arg3 = (float)jarg3;
72284   {
72285     try {
72286       (arg1)->SetRelativeHeight(arg2,arg3);
72287     } catch (std::out_of_range& e) {
72288       {
72289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72290       };
72291     } catch (std::exception& e) {
72292       {
72293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72294       };
72295     } catch (...) {
72296       {
72297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72298       };
72299     }
72300   }
72301 }
72302
72303
72304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
72305   float jresult ;
72306   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72307   unsigned int arg2 ;
72308   float result;
72309
72310   arg1 = (Dali::Toolkit::TableView *)jarg1;
72311   arg2 = (unsigned int)jarg2;
72312   {
72313     try {
72314       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
72315     } catch (std::out_of_range& e) {
72316       {
72317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72318       };
72319     } catch (std::exception& e) {
72320       {
72321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72322       };
72323     } catch (...) {
72324       {
72325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72326       };
72327     }
72328   }
72329   jresult = result;
72330   return jresult;
72331 }
72332
72333
72334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72335   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72336   unsigned int arg2 ;
72337   float arg3 ;
72338
72339   arg1 = (Dali::Toolkit::TableView *)jarg1;
72340   arg2 = (unsigned int)jarg2;
72341   arg3 = (float)jarg3;
72342   {
72343     try {
72344       (arg1)->SetFixedWidth(arg2,arg3);
72345     } catch (std::out_of_range& e) {
72346       {
72347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72348       };
72349     } catch (std::exception& e) {
72350       {
72351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72352       };
72353     } catch (...) {
72354       {
72355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72356       };
72357     }
72358   }
72359 }
72360
72361
72362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
72363   float jresult ;
72364   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72365   unsigned int arg2 ;
72366   float result;
72367
72368   arg1 = (Dali::Toolkit::TableView *)jarg1;
72369   arg2 = (unsigned int)jarg2;
72370   {
72371     try {
72372       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
72373     } catch (std::out_of_range& e) {
72374       {
72375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72376       };
72377     } catch (std::exception& e) {
72378       {
72379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72380       };
72381     } catch (...) {
72382       {
72383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72384       };
72385     }
72386   }
72387   jresult = result;
72388   return jresult;
72389 }
72390
72391
72392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72393   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72394   unsigned int arg2 ;
72395   float arg3 ;
72396
72397   arg1 = (Dali::Toolkit::TableView *)jarg1;
72398   arg2 = (unsigned int)jarg2;
72399   arg3 = (float)jarg3;
72400   {
72401     try {
72402       (arg1)->SetRelativeWidth(arg2,arg3);
72403     } catch (std::out_of_range& e) {
72404       {
72405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72406       };
72407     } catch (std::exception& e) {
72408       {
72409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72410       };
72411     } catch (...) {
72412       {
72413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72414       };
72415     }
72416   }
72417 }
72418
72419
72420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
72421   float jresult ;
72422   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72423   unsigned int arg2 ;
72424   float result;
72425
72426   arg1 = (Dali::Toolkit::TableView *)jarg1;
72427   arg2 = (unsigned int)jarg2;
72428   {
72429     try {
72430       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
72431     } catch (std::out_of_range& e) {
72432       {
72433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72434       };
72435     } catch (std::exception& e) {
72436       {
72437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72438       };
72439     } catch (...) {
72440       {
72441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72442       };
72443     }
72444   }
72445   jresult = result;
72446   return jresult;
72447 }
72448
72449
72450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
72451   unsigned int jresult ;
72452   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72453   unsigned int result;
72454
72455   arg1 = (Dali::Toolkit::TableView *)jarg1;
72456   {
72457     try {
72458       result = (unsigned int)(arg1)->GetRows();
72459     } catch (std::out_of_range& e) {
72460       {
72461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72462       };
72463     } catch (std::exception& e) {
72464       {
72465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72466       };
72467     } catch (...) {
72468       {
72469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72470       };
72471     }
72472   }
72473   jresult = result;
72474   return jresult;
72475 }
72476
72477
72478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
72479   unsigned int jresult ;
72480   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72481   unsigned int result;
72482
72483   arg1 = (Dali::Toolkit::TableView *)jarg1;
72484   {
72485     try {
72486       result = (unsigned int)(arg1)->GetColumns();
72487     } catch (std::out_of_range& e) {
72488       {
72489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72490       };
72491     } catch (std::exception& e) {
72492       {
72493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72494       };
72495     } catch (...) {
72496       {
72497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72498       };
72499     }
72500   }
72501   jresult = result;
72502   return jresult;
72503 }
72504
72505
72506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
72507   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72508   Dali::Toolkit::TableView::CellPosition arg2 ;
72509   Dali::HorizontalAlignment::Type arg3 ;
72510   Dali::VerticalAlignment::Type arg4 ;
72511   Dali::Toolkit::TableView::CellPosition *argp2 ;
72512
72513   arg1 = (Dali::Toolkit::TableView *)jarg1;
72514   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
72515   if (!argp2) {
72516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
72517     return ;
72518   }
72519   arg2 = *argp2;
72520   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
72521   arg4 = (Dali::VerticalAlignment::Type)jarg4;
72522   {
72523     try {
72524       (arg1)->SetCellAlignment(arg2,arg3,arg4);
72525     } catch (std::out_of_range& e) {
72526       {
72527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72528       };
72529     } catch (std::exception& e) {
72530       {
72531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72532       };
72533     } catch (...) {
72534       {
72535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72536       };
72537     }
72538   }
72539 }
72540
72541
72542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
72543   unsigned int jresult ;
72544   unsigned int result;
72545
72546   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
72547   jresult = result;
72548   return jresult;
72549 }
72550
72551
72552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
72553   int jresult ;
72554   int result;
72555
72556   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
72557   jresult = (int)result;
72558   return jresult;
72559 }
72560
72561
72562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
72563   int jresult ;
72564   int result;
72565
72566   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
72567   jresult = (int)result;
72568   return jresult;
72569 }
72570
72571
72572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
72573   int jresult ;
72574   int result;
72575
72576   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
72577   jresult = (int)result;
72578   return jresult;
72579 }
72580
72581
72582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
72583   int jresult ;
72584   int result;
72585
72586   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
72587   jresult = (int)result;
72588   return jresult;
72589 }
72590
72591
72592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
72593   int jresult ;
72594   int result;
72595
72596   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
72597   jresult = (int)result;
72598   return jresult;
72599 }
72600
72601
72602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
72603   int jresult ;
72604   int result;
72605
72606   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
72607   jresult = (int)result;
72608   return jresult;
72609 }
72610
72611
72612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
72613   int jresult ;
72614   int result;
72615
72616   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
72617   jresult = (int)result;
72618   return jresult;
72619 }
72620
72621
72622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
72623   int jresult ;
72624   int result;
72625
72626   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
72627   jresult = (int)result;
72628   return jresult;
72629 }
72630
72631
72632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
72633   int jresult ;
72634   int result;
72635
72636   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
72637   jresult = (int)result;
72638   return jresult;
72639 }
72640
72641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_ANIMATABLE_get() {
72642   int jresult ;
72643   int result;
72644
72645   result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_COLOR_ANIMATABLE;
72646   jresult = (int)result;
72647   return jresult;
72648 }
72649
72650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
72651   int jresult ;
72652   int result;
72653
72654   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
72655   jresult = (int)result;
72656   return jresult;
72657 }
72658
72659
72660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
72661   int jresult ;
72662   int result;
72663
72664   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
72665   jresult = (int)result;
72666   return jresult;
72667 }
72668
72669
72670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
72671   int jresult ;
72672   int result;
72673
72674   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
72675   jresult = (int)result;
72676   return jresult;
72677 }
72678
72679
72680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
72681   int jresult ;
72682   int result;
72683
72684   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
72685   jresult = (int)result;
72686   return jresult;
72687 }
72688
72689
72690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
72691   int jresult ;
72692   int result;
72693
72694   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
72695   jresult = (int)result;
72696   return jresult;
72697 }
72698
72699
72700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
72701   int jresult ;
72702   int result;
72703
72704   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
72705   jresult = (int)result;
72706   return jresult;
72707 }
72708
72709
72710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
72711   int jresult ;
72712   int result;
72713
72714   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
72715   jresult = (int)result;
72716   return jresult;
72717 }
72718
72719
72720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
72721   int jresult ;
72722   int result;
72723
72724   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
72725   jresult = (int)result;
72726   return jresult;
72727 }
72728
72729
72730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
72731   int jresult ;
72732   int result;
72733
72734   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
72735   jresult = (int)result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
72741   int jresult ;
72742   int result;
72743
72744   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
72745   jresult = (int)result;
72746   return jresult;
72747 }
72748
72749
72750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
72751   int jresult ;
72752   int result;
72753
72754   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
72755   jresult = (int)result;
72756   return jresult;
72757 }
72758
72759
72760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
72761   int jresult ;
72762   int result;
72763
72764   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
72765   jresult = (int)result;
72766   return jresult;
72767 }
72768
72769
72770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
72771   int jresult ;
72772   int result;
72773
72774   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
72775   jresult = (int)result;
72776   return jresult;
72777 }
72778
72779
72780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
72781   int jresult ;
72782   int result;
72783
72784   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
72785   jresult = (int)result;
72786   return jresult;
72787 }
72788
72789
72790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
72791   int jresult ;
72792   int result;
72793
72794   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
72795   jresult = (int)result;
72796   return jresult;
72797 }
72798
72799
72800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
72801   void * jresult ;
72802   Dali::Toolkit::TextLabel::Property *result = 0 ;
72803
72804   {
72805     try {
72806       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
72807     } catch (std::out_of_range& e) {
72808       {
72809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72810       };
72811     } catch (std::exception& e) {
72812       {
72813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72814       };
72815     } catch (...) {
72816       {
72817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72818       };
72819     }
72820   }
72821   jresult = (void *)result;
72822   return jresult;
72823 }
72824
72825
72826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
72827   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
72828
72829   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
72830   {
72831     try {
72832       delete arg1;
72833     } catch (std::out_of_range& e) {
72834       {
72835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72836       };
72837     } catch (std::exception& e) {
72838       {
72839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72840       };
72841     } catch (...) {
72842       {
72843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72844       };
72845     }
72846   }
72847 }
72848
72849
72850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
72851   void * jresult ;
72852   Dali::Toolkit::TextLabel result;
72853
72854   {
72855     try {
72856       result = Dali::Toolkit::TextLabel::New();
72857     } catch (std::out_of_range& e) {
72858       {
72859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72860       };
72861     } catch (std::exception& e) {
72862       {
72863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72864       };
72865     } catch (...) {
72866       {
72867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72868       };
72869     }
72870   }
72871   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72872   return jresult;
72873 }
72874
72875
72876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
72877   void * jresult ;
72878   std::string *arg1 = 0 ;
72879   Dali::Toolkit::TextLabel result;
72880
72881   if (!jarg1) {
72882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72883     return 0;
72884   }
72885   std::string arg1_str(jarg1);
72886   arg1 = &arg1_str;
72887   {
72888     try {
72889       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
72890     } catch (std::out_of_range& e) {
72891       {
72892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72893       };
72894     } catch (std::exception& e) {
72895       {
72896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72897       };
72898     } catch (...) {
72899       {
72900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72901       };
72902     }
72903   }
72904   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
72905
72906   //argout typemap for const std::string&
72907
72908   return jresult;
72909 }
72910
72911
72912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
72913   void * jresult ;
72914   Dali::Toolkit::TextLabel *result = 0 ;
72915
72916   {
72917     try {
72918       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
72919     } catch (std::out_of_range& e) {
72920       {
72921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72922       };
72923     } catch (std::exception& e) {
72924       {
72925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72926       };
72927     } catch (...) {
72928       {
72929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72930       };
72931     }
72932   }
72933   jresult = (void *)result;
72934   return jresult;
72935 }
72936
72937
72938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
72939   void * jresult ;
72940   Dali::Toolkit::TextLabel *arg1 = 0 ;
72941   Dali::Toolkit::TextLabel *result = 0 ;
72942
72943   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72944   if (!arg1) {
72945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72946     return 0;
72947   }
72948   {
72949     try {
72950       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
72951     } catch (std::out_of_range& e) {
72952       {
72953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72954       };
72955     } catch (std::exception& e) {
72956       {
72957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72958       };
72959     } catch (...) {
72960       {
72961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72962       };
72963     }
72964   }
72965   jresult = (void *)result;
72966   return jresult;
72967 }
72968
72969
72970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
72971   void * jresult ;
72972   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
72973   Dali::Toolkit::TextLabel *arg2 = 0 ;
72974   Dali::Toolkit::TextLabel *result = 0 ;
72975
72976   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
72977   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
72978   if (!arg2) {
72979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
72980     return 0;
72981   }
72982   {
72983     try {
72984       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
72985     } catch (std::out_of_range& e) {
72986       {
72987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72988       };
72989     } catch (std::exception& e) {
72990       {
72991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72992       };
72993     } catch (...) {
72994       {
72995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72996       };
72997     }
72998   }
72999   jresult = (void *)result;
73000   return jresult;
73001 }
73002
73003
73004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
73005   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
73006
73007   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
73008   {
73009     try {
73010       delete arg1;
73011     } catch (std::out_of_range& e) {
73012       {
73013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73014       };
73015     } catch (std::exception& e) {
73016       {
73017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73018       };
73019     } catch (...) {
73020       {
73021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73022       };
73023     }
73024   }
73025 }
73026
73027
73028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
73029   void * jresult ;
73030   Dali::BaseHandle arg1 ;
73031   Dali::BaseHandle *argp1 ;
73032   Dali::Toolkit::TextLabel result;
73033
73034   argp1 = (Dali::BaseHandle *)jarg1;
73035   if (!argp1) {
73036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73037     return 0;
73038   }
73039   arg1 = *argp1;
73040   {
73041     try {
73042       result = Dali::Toolkit::TextLabel::DownCast(arg1);
73043     } catch (std::out_of_range& e) {
73044       {
73045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73046       };
73047     } catch (std::exception& e) {
73048       {
73049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73050       };
73051     } catch (...) {
73052       {
73053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73054       };
73055     }
73056   }
73057   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
73058   return jresult;
73059 }
73060
73061
73062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
73063   void * jresult ;
73064   Dali::Toolkit::AccessibilityManager *result = 0 ;
73065
73066   {
73067     try {
73068       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
73069     } catch (std::out_of_range& e) {
73070       {
73071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73072       };
73073     } catch (std::exception& e) {
73074       {
73075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73076       };
73077     } catch (...) {
73078       {
73079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73080       };
73081     }
73082   }
73083   jresult = (void *)result;
73084   return jresult;
73085 }
73086
73087
73088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
73089   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73090
73091   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73092   {
73093     try {
73094       delete arg1;
73095     } catch (std::out_of_range& e) {
73096       {
73097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73098       };
73099     } catch (std::exception& e) {
73100       {
73101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73102       };
73103     } catch (...) {
73104       {
73105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73106       };
73107     }
73108   }
73109 }
73110
73111
73112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
73113   void * jresult ;
73114   Dali::Toolkit::AccessibilityManager result;
73115
73116   {
73117     try {
73118       result = Dali::Toolkit::AccessibilityManager::Get();
73119     } catch (std::out_of_range& e) {
73120       {
73121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73122       };
73123     } catch (std::exception& e) {
73124       {
73125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73126       };
73127     } catch (...) {
73128       {
73129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73130       };
73131     }
73132   }
73133   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
73134   return jresult;
73135 }
73136
73137
73138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
73139   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73140   Dali::Actor arg2 ;
73141   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73142   std::string *arg4 = 0 ;
73143   Dali::Actor *argp2 ;
73144
73145   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73146   argp2 = (Dali::Actor *)jarg2;
73147   if (!argp2) {
73148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73149     return ;
73150   }
73151   arg2 = *argp2;
73152   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73153   if (!jarg4) {
73154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
73155     return ;
73156   }
73157   std::string arg4_str(jarg4);
73158   arg4 = &arg4_str;
73159   {
73160     try {
73161       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
73162     } catch (std::out_of_range& e) {
73163       {
73164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73165       };
73166     } catch (std::exception& e) {
73167       {
73168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73169       };
73170     } catch (...) {
73171       {
73172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73173       };
73174     }
73175   }
73176
73177   //argout typemap for const std::string&
73178
73179 }
73180
73181
73182 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
73183   char * jresult ;
73184   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73185   Dali::Actor arg2 ;
73186   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73187   Dali::Actor *argp2 ;
73188   std::string result;
73189
73190   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73191   argp2 = (Dali::Actor *)jarg2;
73192   if (!argp2) {
73193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73194     return 0;
73195   }
73196   arg2 = *argp2;
73197   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73198   {
73199     try {
73200       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
73201     } catch (std::out_of_range& e) {
73202       {
73203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73204       };
73205     } catch (std::exception& e) {
73206       {
73207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73208       };
73209     } catch (...) {
73210       {
73211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73212       };
73213     }
73214   }
73215   jresult = SWIG_csharp_string_callback((&result)->c_str());
73216   return jresult;
73217 }
73218
73219
73220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
73221   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73222   Dali::Actor arg2 ;
73223   unsigned int arg3 ;
73224   Dali::Actor *argp2 ;
73225
73226   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73227   argp2 = (Dali::Actor *)jarg2;
73228   if (!argp2) {
73229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73230     return ;
73231   }
73232   arg2 = *argp2;
73233   arg3 = (unsigned int)jarg3;
73234   {
73235     try {
73236       (arg1)->SetFocusOrder(arg2,arg3);
73237     } catch (std::out_of_range& e) {
73238       {
73239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73240       };
73241     } catch (std::exception& e) {
73242       {
73243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73244       };
73245     } catch (...) {
73246       {
73247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73248       };
73249     }
73250   }
73251 }
73252
73253
73254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
73255   unsigned int jresult ;
73256   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73257   Dali::Actor arg2 ;
73258   Dali::Actor *argp2 ;
73259   unsigned int result;
73260
73261   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73262   argp2 = (Dali::Actor *)jarg2;
73263   if (!argp2) {
73264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73265     return 0;
73266   }
73267   arg2 = *argp2;
73268   {
73269     try {
73270       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
73271     } catch (std::out_of_range& e) {
73272       {
73273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73274       };
73275     } catch (std::exception& e) {
73276       {
73277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73278       };
73279     } catch (...) {
73280       {
73281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73282       };
73283     }
73284   }
73285   jresult = result;
73286   return jresult;
73287 }
73288
73289
73290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
73291   unsigned int jresult ;
73292   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73293   unsigned int result;
73294
73295   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73296   {
73297     try {
73298       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
73299     } catch (std::out_of_range& e) {
73300       {
73301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73302       };
73303     } catch (std::exception& e) {
73304       {
73305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73306       };
73307     } catch (...) {
73308       {
73309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73310       };
73311     }
73312   }
73313   jresult = result;
73314   return jresult;
73315 }
73316
73317
73318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
73319   void * jresult ;
73320   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73321   unsigned int arg2 ;
73322   Dali::Actor result;
73323
73324   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73325   arg2 = (unsigned int)jarg2;
73326   {
73327     try {
73328       result = (arg1)->GetActorByFocusOrder(arg2);
73329     } catch (std::out_of_range& e) {
73330       {
73331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73332       };
73333     } catch (std::exception& e) {
73334       {
73335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73336       };
73337     } catch (...) {
73338       {
73339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73340       };
73341     }
73342   }
73343   jresult = new Dali::Actor((const Dali::Actor &)result);
73344   return jresult;
73345 }
73346
73347
73348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
73349   unsigned int jresult ;
73350   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73351   Dali::Actor arg2 ;
73352   Dali::Actor *argp2 ;
73353   bool result;
73354
73355   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73356   argp2 = (Dali::Actor *)jarg2;
73357   if (!argp2) {
73358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73359     return 0;
73360   }
73361   arg2 = *argp2;
73362   {
73363     try {
73364       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
73365     } catch (std::out_of_range& e) {
73366       {
73367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73368       };
73369     } catch (std::exception& e) {
73370       {
73371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73372       };
73373     } catch (...) {
73374       {
73375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73376       };
73377     }
73378   }
73379   jresult = result;
73380   return jresult;
73381 }
73382
73383
73384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
73385   void * jresult ;
73386   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73387   Dali::Actor result;
73388
73389   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73390   {
73391     try {
73392       result = (arg1)->GetCurrentFocusActor();
73393     } catch (std::out_of_range& e) {
73394       {
73395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73396       };
73397     } catch (std::exception& e) {
73398       {
73399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73400       };
73401     } catch (...) {
73402       {
73403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73404       };
73405     }
73406   }
73407   jresult = new Dali::Actor((const Dali::Actor &)result);
73408   return jresult;
73409 }
73410
73411
73412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
73413   void * jresult ;
73414   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73415   Dali::Actor result;
73416
73417   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73418   {
73419     try {
73420       result = (arg1)->GetCurrentFocusGroup();
73421     } catch (std::out_of_range& e) {
73422       {
73423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73424       };
73425     } catch (std::exception& e) {
73426       {
73427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73428       };
73429     } catch (...) {
73430       {
73431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73432       };
73433     }
73434   }
73435   jresult = new Dali::Actor((const Dali::Actor &)result);
73436   return jresult;
73437 }
73438
73439
73440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
73441   unsigned int jresult ;
73442   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73443   unsigned int result;
73444
73445   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73446   {
73447     try {
73448       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
73449     } catch (std::out_of_range& e) {
73450       {
73451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73452       };
73453     } catch (std::exception& e) {
73454       {
73455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73456       };
73457     } catch (...) {
73458       {
73459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73460       };
73461     }
73462   }
73463   jresult = result;
73464   return jresult;
73465 }
73466
73467
73468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
73469   unsigned int jresult ;
73470   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73471   bool result;
73472
73473   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73474   {
73475     try {
73476       result = (bool)(arg1)->MoveFocusForward();
73477     } catch (std::out_of_range& e) {
73478       {
73479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73480       };
73481     } catch (std::exception& e) {
73482       {
73483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73484       };
73485     } catch (...) {
73486       {
73487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73488       };
73489     }
73490   }
73491   jresult = result;
73492   return jresult;
73493 }
73494
73495
73496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
73497   unsigned int jresult ;
73498   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73499   bool result;
73500
73501   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73502   {
73503     try {
73504       result = (bool)(arg1)->MoveFocusBackward();
73505     } catch (std::out_of_range& e) {
73506       {
73507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73508       };
73509     } catch (std::exception& e) {
73510       {
73511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73512       };
73513     } catch (...) {
73514       {
73515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73516       };
73517     }
73518   }
73519   jresult = result;
73520   return jresult;
73521 }
73522
73523
73524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
73525   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73526
73527   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73528   {
73529     try {
73530       (arg1)->ClearFocus();
73531     } catch (std::out_of_range& e) {
73532       {
73533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73534       };
73535     } catch (std::exception& e) {
73536       {
73537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73538       };
73539     } catch (...) {
73540       {
73541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73542       };
73543     }
73544   }
73545 }
73546
73547
73548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
73549   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73550
73551   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73552   {
73553     try {
73554       (arg1)->Reset();
73555     } catch (std::out_of_range& e) {
73556       {
73557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73558       };
73559     } catch (std::exception& e) {
73560       {
73561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73562       };
73563     } catch (...) {
73564       {
73565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73566       };
73567     }
73568   }
73569 }
73570
73571
73572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
73573   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73574   Dali::Actor arg2 ;
73575   bool arg3 ;
73576   Dali::Actor *argp2 ;
73577
73578   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73579   argp2 = (Dali::Actor *)jarg2;
73580   if (!argp2) {
73581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73582     return ;
73583   }
73584   arg2 = *argp2;
73585   arg3 = jarg3 ? true : false;
73586   {
73587     try {
73588       (arg1)->SetFocusGroup(arg2,arg3);
73589     } catch (std::out_of_range& e) {
73590       {
73591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73592       };
73593     } catch (std::exception& e) {
73594       {
73595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73596       };
73597     } catch (...) {
73598       {
73599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73600       };
73601     }
73602   }
73603 }
73604
73605
73606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
73607   unsigned int jresult ;
73608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73609   Dali::Actor arg2 ;
73610   Dali::Actor *argp2 ;
73611   bool result;
73612
73613   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73614   argp2 = (Dali::Actor *)jarg2;
73615   if (!argp2) {
73616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73617     return 0;
73618   }
73619   arg2 = *argp2;
73620   {
73621     try {
73622       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
73623     } catch (std::out_of_range& e) {
73624       {
73625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73626       };
73627     } catch (std::exception& e) {
73628       {
73629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73630       };
73631     } catch (...) {
73632       {
73633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73634       };
73635     }
73636   }
73637   jresult = result;
73638   return jresult;
73639 }
73640
73641
73642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
73643   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73644   bool arg2 ;
73645
73646   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73647   arg2 = jarg2 ? true : false;
73648   {
73649     try {
73650       (arg1)->SetGroupMode(arg2);
73651     } catch (std::out_of_range& e) {
73652       {
73653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73654       };
73655     } catch (std::exception& e) {
73656       {
73657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73658       };
73659     } catch (...) {
73660       {
73661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73662       };
73663     }
73664   }
73665 }
73666
73667
73668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
73669   unsigned int jresult ;
73670   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73671   bool result;
73672
73673   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73674   {
73675     try {
73676       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
73677     } catch (std::out_of_range& e) {
73678       {
73679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73680       };
73681     } catch (std::exception& e) {
73682       {
73683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73684       };
73685     } catch (...) {
73686       {
73687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73688       };
73689     }
73690   }
73691   jresult = result;
73692   return jresult;
73693 }
73694
73695
73696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
73697   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73698   bool arg2 ;
73699
73700   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73701   arg2 = jarg2 ? true : false;
73702   {
73703     try {
73704       (arg1)->SetWrapMode(arg2);
73705     } catch (std::out_of_range& e) {
73706       {
73707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73708       };
73709     } catch (std::exception& e) {
73710       {
73711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73712       };
73713     } catch (...) {
73714       {
73715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73716       };
73717     }
73718   }
73719 }
73720
73721
73722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
73723   unsigned int jresult ;
73724   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73725   bool result;
73726
73727   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73728   {
73729     try {
73730       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
73731     } catch (std::out_of_range& e) {
73732       {
73733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73734       };
73735     } catch (std::exception& e) {
73736       {
73737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73738       };
73739     } catch (...) {
73740       {
73741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73742       };
73743     }
73744   }
73745   jresult = result;
73746   return jresult;
73747 }
73748
73749
73750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
73751   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73752   Dali::Actor arg2 ;
73753   Dali::Actor *argp2 ;
73754
73755   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73756   argp2 = (Dali::Actor *)jarg2;
73757   if (!argp2) {
73758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73759     return ;
73760   }
73761   arg2 = *argp2;
73762   {
73763     try {
73764       (arg1)->SetFocusIndicatorActor(arg2);
73765     } catch (std::out_of_range& e) {
73766       {
73767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73768       };
73769     } catch (std::exception& e) {
73770       {
73771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73772       };
73773     } catch (...) {
73774       {
73775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73776       };
73777     }
73778   }
73779 }
73780
73781
73782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
73783   void * jresult ;
73784   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73785   Dali::Actor result;
73786
73787   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73788   {
73789     try {
73790       result = (arg1)->GetFocusIndicatorActor();
73791     } catch (std::out_of_range& e) {
73792       {
73793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73794       };
73795     } catch (std::exception& e) {
73796       {
73797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73798       };
73799     } catch (...) {
73800       {
73801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73802       };
73803     }
73804   }
73805   jresult = new Dali::Actor((const Dali::Actor &)result);
73806   return jresult;
73807 }
73808
73809
73810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
73811   void * jresult ;
73812   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73813   Dali::Actor arg2 ;
73814   Dali::Actor *argp2 ;
73815   Dali::Actor result;
73816
73817   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73818   argp2 = (Dali::Actor *)jarg2;
73819   if (!argp2) {
73820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73821     return 0;
73822   }
73823   arg2 = *argp2;
73824   {
73825     try {
73826       result = (arg1)->GetFocusGroup(arg2);
73827     } catch (std::out_of_range& e) {
73828       {
73829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73830       };
73831     } catch (std::exception& e) {
73832       {
73833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73834       };
73835     } catch (...) {
73836       {
73837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73838       };
73839     }
73840   }
73841   jresult = new Dali::Actor((const Dali::Actor &)result);
73842   return jresult;
73843 }
73844
73845
73846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
73847   void * jresult ;
73848   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73849   Dali::Vector2 result;
73850
73851   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73852   {
73853     try {
73854       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
73855     } catch (std::out_of_range& e) {
73856       {
73857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73858       };
73859     } catch (std::exception& e) {
73860       {
73861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73862       };
73863     } catch (...) {
73864       {
73865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73866       };
73867     }
73868   }
73869   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73870   return jresult;
73871 }
73872
73873
73874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
73875   void * jresult ;
73876   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73877   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
73878
73879   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73880   {
73881     try {
73882       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
73883     } catch (std::out_of_range& e) {
73884       {
73885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73886       };
73887     } catch (std::exception& e) {
73888       {
73889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73890       };
73891     } catch (...) {
73892       {
73893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73894       };
73895     }
73896   }
73897   jresult = (void *)result;
73898   return jresult;
73899 }
73900
73901
73902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
73903   void * jresult ;
73904   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73905   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
73906
73907   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73908   {
73909     try {
73910       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
73911     } catch (std::out_of_range& e) {
73912       {
73913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73914       };
73915     } catch (std::exception& e) {
73916       {
73917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73918       };
73919     } catch (...) {
73920       {
73921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73922       };
73923     }
73924   }
73925   jresult = (void *)result;
73926   return jresult;
73927 }
73928
73929
73930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
73931   void * jresult ;
73932   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73933   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
73934
73935   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73936   {
73937     try {
73938       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
73939     } catch (std::out_of_range& e) {
73940       {
73941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73942       };
73943     } catch (std::exception& e) {
73944       {
73945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73946       };
73947     } catch (...) {
73948       {
73949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73950       };
73951     }
73952   }
73953   jresult = (void *)result;
73954   return jresult;
73955 }
73956
73957
73958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
73959   void * jresult ;
73960   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73961   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73962
73963   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73964   {
73965     try {
73966       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
73967     } catch (std::out_of_range& e) {
73968       {
73969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73970       };
73971     } catch (std::exception& e) {
73972       {
73973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73974       };
73975     } catch (...) {
73976       {
73977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73978       };
73979     }
73980   }
73981   jresult = (void *)result;
73982   return jresult;
73983 }
73984
73985
73986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
73987   void * jresult ;
73988   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73989   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
73990
73991   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73992   {
73993     try {
73994       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
73995     } catch (std::out_of_range& e) {
73996       {
73997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73998       };
73999     } catch (std::exception& e) {
74000       {
74001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74002       };
74003     } catch (...) {
74004       {
74005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74006       };
74007     }
74008   }
74009   jresult = (void *)result;
74010   return jresult;
74011 }
74012
74013
74014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
74015   void * jresult ;
74016   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74017   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74018
74019   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74020   {
74021     try {
74022       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
74023     } catch (std::out_of_range& e) {
74024       {
74025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74026       };
74027     } catch (std::exception& e) {
74028       {
74029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74030       };
74031     } catch (...) {
74032       {
74033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74034       };
74035     }
74036   }
74037   jresult = (void *)result;
74038   return jresult;
74039 }
74040
74041
74042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
74043   void * jresult ;
74044   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74045   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74046
74047   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74048   {
74049     try {
74050       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
74051     } catch (std::out_of_range& e) {
74052       {
74053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74054       };
74055     } catch (std::exception& e) {
74056       {
74057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74058       };
74059     } catch (...) {
74060       {
74061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74062       };
74063     }
74064   }
74065   jresult = (void *)result;
74066   return jresult;
74067 }
74068
74069
74070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
74071   void * jresult ;
74072   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74073   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74074
74075   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74076   {
74077     try {
74078       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
74079     } catch (std::out_of_range& e) {
74080       {
74081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74082       };
74083     } catch (std::exception& e) {
74084       {
74085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74086       };
74087     } catch (...) {
74088       {
74089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74090       };
74091     }
74092   }
74093   jresult = (void *)result;
74094   return jresult;
74095 }
74096
74097
74098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
74099   void * jresult ;
74100   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74101   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74102
74103   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74104   {
74105     try {
74106       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
74107     } catch (std::out_of_range& e) {
74108       {
74109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74110       };
74111     } catch (std::exception& e) {
74112       {
74113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74114       };
74115     } catch (...) {
74116       {
74117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74118       };
74119     }
74120   }
74121   jresult = (void *)result;
74122   return jresult;
74123 }
74124
74125
74126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
74127   void * jresult ;
74128   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74129   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74130
74131   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74132   {
74133     try {
74134       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
74135     } catch (std::out_of_range& e) {
74136       {
74137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74138       };
74139     } catch (std::exception& e) {
74140       {
74141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74142       };
74143     } catch (...) {
74144       {
74145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74146       };
74147     }
74148   }
74149   jresult = (void *)result;
74150   return jresult;
74151 }
74152
74153
74154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
74155   void * jresult ;
74156   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74157   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74158
74159   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74160   {
74161     try {
74162       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
74163     } catch (std::out_of_range& e) {
74164       {
74165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74166       };
74167     } catch (std::exception& e) {
74168       {
74169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74170       };
74171     } catch (...) {
74172       {
74173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74174       };
74175     }
74176   }
74177   jresult = (void *)result;
74178   return jresult;
74179 }
74180
74181
74182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
74183   void * jresult ;
74184   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74185   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74186
74187   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74188   {
74189     try {
74190       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
74191     } catch (std::out_of_range& e) {
74192       {
74193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74194       };
74195     } catch (std::exception& e) {
74196       {
74197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74198       };
74199     } catch (...) {
74200       {
74201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74202       };
74203     }
74204   }
74205   jresult = (void *)result;
74206   return jresult;
74207 }
74208
74209
74210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
74211   void * jresult ;
74212   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74213   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74214
74215   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74216   {
74217     try {
74218       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
74219     } catch (std::out_of_range& e) {
74220       {
74221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74222       };
74223     } catch (std::exception& e) {
74224       {
74225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74226       };
74227     } catch (...) {
74228       {
74229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74230       };
74231     }
74232   }
74233   jresult = (void *)result;
74234   return jresult;
74235 }
74236
74237
74238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
74239   void * jresult ;
74240   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74241   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74242
74243   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74244   {
74245     try {
74246       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
74247     } catch (std::out_of_range& e) {
74248       {
74249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74250       };
74251     } catch (std::exception& e) {
74252       {
74253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74254       };
74255     } catch (...) {
74256       {
74257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74258       };
74259     }
74260   }
74261   jresult = (void *)result;
74262   return jresult;
74263 }
74264
74265
74266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
74267   void * jresult ;
74268   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74269   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74270
74271   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74272   {
74273     try {
74274       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
74275     } catch (std::out_of_range& e) {
74276       {
74277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74278       };
74279     } catch (std::exception& e) {
74280       {
74281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74282       };
74283     } catch (...) {
74284       {
74285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74286       };
74287     }
74288   }
74289   jresult = (void *)result;
74290   return jresult;
74291 }
74292
74293
74294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
74295   void * jresult ;
74296   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74297   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74298
74299   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74300   {
74301     try {
74302       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
74303     } catch (std::out_of_range& e) {
74304       {
74305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74306       };
74307     } catch (std::exception& e) {
74308       {
74309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74310       };
74311     } catch (...) {
74312       {
74313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74314       };
74315     }
74316   }
74317   jresult = (void *)result;
74318   return jresult;
74319 }
74320
74321
74322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
74323   void * jresult ;
74324   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74325   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74326
74327   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74328   {
74329     try {
74330       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
74331     } catch (std::out_of_range& e) {
74332       {
74333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74334       };
74335     } catch (std::exception& e) {
74336       {
74337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74338       };
74339     } catch (...) {
74340       {
74341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74342       };
74343     }
74344   }
74345   jresult = (void *)result;
74346   return jresult;
74347 }
74348
74349
74350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
74351   void * jresult ;
74352   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74353   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74354
74355   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74356   {
74357     try {
74358       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
74359     } catch (std::out_of_range& e) {
74360       {
74361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74362       };
74363     } catch (std::exception& e) {
74364       {
74365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74366       };
74367     } catch (...) {
74368       {
74369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74370       };
74371     }
74372   }
74373   jresult = (void *)result;
74374   return jresult;
74375 }
74376
74377
74378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
74379   void * jresult ;
74380   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74381   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74382
74383   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74384   {
74385     try {
74386       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
74387     } catch (std::out_of_range& e) {
74388       {
74389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74390       };
74391     } catch (std::exception& e) {
74392       {
74393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74394       };
74395     } catch (...) {
74396       {
74397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74398       };
74399     }
74400   }
74401   jresult = (void *)result;
74402   return jresult;
74403 }
74404
74405
74406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
74407   void * jresult ;
74408   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74409   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74410
74411   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74412   {
74413     try {
74414       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
74415     } catch (std::out_of_range& e) {
74416       {
74417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74418       };
74419     } catch (std::exception& e) {
74420       {
74421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74422       };
74423     } catch (...) {
74424       {
74425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74426       };
74427     }
74428   }
74429   jresult = (void *)result;
74430   return jresult;
74431 }
74432
74433
74434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
74435   void * jresult ;
74436   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74437   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74438
74439   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74440   {
74441     try {
74442       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
74443     } catch (std::out_of_range& e) {
74444       {
74445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74446       };
74447     } catch (std::exception& e) {
74448       {
74449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74450       };
74451     } catch (...) {
74452       {
74453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74454       };
74455     }
74456   }
74457   jresult = (void *)result;
74458   return jresult;
74459 }
74460
74461
74462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
74463   void * jresult ;
74464   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74465   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74466
74467   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74468   {
74469     try {
74470       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
74471     } catch (std::out_of_range& e) {
74472       {
74473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74474       };
74475     } catch (std::exception& e) {
74476       {
74477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74478       };
74479     } catch (...) {
74480       {
74481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74482       };
74483     }
74484   }
74485   jresult = (void *)result;
74486   return jresult;
74487 }
74488
74489
74490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
74491   void * jresult ;
74492   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74493   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74494
74495   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74496   {
74497     try {
74498       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
74499     } catch (std::out_of_range& e) {
74500       {
74501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74502       };
74503     } catch (std::exception& e) {
74504       {
74505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74506       };
74507     } catch (...) {
74508       {
74509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74510       };
74511     }
74512   }
74513   jresult = (void *)result;
74514   return jresult;
74515 }
74516
74517
74518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
74519   void * jresult ;
74520   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74521   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74522
74523   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74524   {
74525     try {
74526       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
74527     } catch (std::out_of_range& e) {
74528       {
74529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74530       };
74531     } catch (std::exception& e) {
74532       {
74533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74534       };
74535     } catch (...) {
74536       {
74537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74538       };
74539     }
74540   }
74541   jresult = (void *)result;
74542   return jresult;
74543 }
74544
74545
74546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
74547   void * jresult ;
74548   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74549   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74550
74551   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74552   {
74553     try {
74554       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
74555     } catch (std::out_of_range& e) {
74556       {
74557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74558       };
74559     } catch (std::exception& e) {
74560       {
74561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74562       };
74563     } catch (...) {
74564       {
74565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74566       };
74567     }
74568   }
74569   jresult = (void *)result;
74570   return jresult;
74571 }
74572
74573
74574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
74575   void * jresult ;
74576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74577   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74578
74579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74580   {
74581     try {
74582       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
74583     } catch (std::out_of_range& e) {
74584       {
74585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74586       };
74587     } catch (std::exception& e) {
74588       {
74589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74590       };
74591     } catch (...) {
74592       {
74593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74594       };
74595     }
74596   }
74597   jresult = (void *)result;
74598   return jresult;
74599 }
74600
74601
74602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
74603   void * jresult ;
74604   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74605   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74606
74607   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74608   {
74609     try {
74610       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
74611     } catch (std::out_of_range& e) {
74612       {
74613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74614       };
74615     } catch (std::exception& e) {
74616       {
74617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74618       };
74619     } catch (...) {
74620       {
74621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74622       };
74623     }
74624   }
74625   jresult = (void *)result;
74626   return jresult;
74627 }
74628
74629
74630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
74631   void * jresult ;
74632   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74633   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74634
74635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74636   {
74637     try {
74638       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
74639     } catch (std::out_of_range& e) {
74640       {
74641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74642       };
74643     } catch (std::exception& e) {
74644       {
74645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74646       };
74647     } catch (...) {
74648       {
74649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74650       };
74651     }
74652   }
74653   jresult = (void *)result;
74654   return jresult;
74655 }
74656
74657
74658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
74659   void * jresult ;
74660   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74661   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74662
74663   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74664   {
74665     try {
74666       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
74667     } catch (std::out_of_range& e) {
74668       {
74669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74670       };
74671     } catch (std::exception& e) {
74672       {
74673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74674       };
74675     } catch (...) {
74676       {
74677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74678       };
74679     }
74680   }
74681   jresult = (void *)result;
74682   return jresult;
74683 }
74684
74685
74686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
74687   void * jresult ;
74688   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74689   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
74690
74691   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74692   {
74693     try {
74694       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
74695     } catch (std::out_of_range& e) {
74696       {
74697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74698       };
74699     } catch (std::exception& e) {
74700       {
74701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74702       };
74703     } catch (...) {
74704       {
74705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74706       };
74707     }
74708   }
74709   jresult = (void *)result;
74710   return jresult;
74711 }
74712
74713
74714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
74715   void * jresult ;
74716   Dali::Toolkit::StyleManager *result = 0 ;
74717
74718   {
74719     try {
74720       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
74721     } catch (std::out_of_range& e) {
74722       {
74723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74724       };
74725     } catch (std::exception& e) {
74726       {
74727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74728       };
74729     } catch (...) {
74730       {
74731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74732       };
74733     }
74734   }
74735   jresult = (void *)result;
74736   return jresult;
74737 }
74738
74739
74740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
74741   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74742
74743   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74744   {
74745     try {
74746       delete arg1;
74747     } catch (std::out_of_range& e) {
74748       {
74749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74750       };
74751     } catch (std::exception& e) {
74752       {
74753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74754       };
74755     } catch (...) {
74756       {
74757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74758       };
74759     }
74760   }
74761 }
74762
74763
74764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
74765   void * jresult ;
74766   Dali::Toolkit::StyleManager result;
74767
74768   {
74769     try {
74770       result = Dali::Toolkit::StyleManager::Get();
74771     } catch (std::out_of_range& e) {
74772       {
74773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74774       };
74775     } catch (std::exception& e) {
74776       {
74777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74778       };
74779     } catch (...) {
74780       {
74781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74782       };
74783     }
74784   }
74785   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
74786   return jresult;
74787 }
74788
74789
74790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
74791   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74792   std::string *arg2 = 0 ;
74793
74794   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74795   if (!jarg2) {
74796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74797     return ;
74798   }
74799   std::string arg2_str(jarg2);
74800   arg2 = &arg2_str;
74801   {
74802     try {
74803       (arg1)->ApplyTheme((std::string const &)*arg2);
74804     } catch (std::out_of_range& e) {
74805       {
74806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74807       };
74808     } catch (std::exception& e) {
74809       {
74810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74811       };
74812     } catch (...) {
74813       {
74814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74815       };
74816     }
74817   }
74818
74819   //argout typemap for const std::string&
74820
74821 }
74822
74823
74824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
74825   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74826
74827   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74828   {
74829     try {
74830       (arg1)->ApplyDefaultTheme();
74831     } catch (std::out_of_range& e) {
74832       {
74833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74834       };
74835     } catch (std::exception& e) {
74836       {
74837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74838       };
74839     } catch (...) {
74840       {
74841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74842       };
74843     }
74844   }
74845 }
74846
74847
74848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74849   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74850   std::string *arg2 = 0 ;
74851   Dali::Property::Value *arg3 = 0 ;
74852
74853   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74854   if (!jarg2) {
74855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74856     return ;
74857   }
74858   std::string arg2_str(jarg2);
74859   arg2 = &arg2_str;
74860   arg3 = (Dali::Property::Value *)jarg3;
74861   if (!arg3) {
74862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
74863     return ;
74864   }
74865   {
74866     try {
74867       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
74868     } catch (std::out_of_range& e) {
74869       {
74870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74871       };
74872     } catch (std::exception& e) {
74873       {
74874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74875       };
74876     } catch (...) {
74877       {
74878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74879       };
74880     }
74881   }
74882
74883   //argout typemap for const std::string&
74884
74885 }
74886
74887
74888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
74889   unsigned int jresult ;
74890   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74891   std::string *arg2 = 0 ;
74892   Dali::Property::Value *arg3 = 0 ;
74893   bool result;
74894
74895   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74896   if (!jarg2) {
74897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74898     return 0;
74899   }
74900   std::string arg2_str(jarg2);
74901   arg2 = &arg2_str;
74902   arg3 = (Dali::Property::Value *)jarg3;
74903   if (!arg3) {
74904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
74905     return 0;
74906   }
74907   {
74908     try {
74909       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
74910     } catch (std::out_of_range& e) {
74911       {
74912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74913       };
74914     } catch (std::exception& e) {
74915       {
74916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74917       };
74918     } catch (...) {
74919       {
74920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74921       };
74922     }
74923   }
74924   jresult = result;
74925
74926   //argout typemap for const std::string&
74927
74928   return jresult;
74929 }
74930
74931
74932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
74933   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74934   Dali::Toolkit::Control arg2 ;
74935   std::string *arg3 = 0 ;
74936   std::string *arg4 = 0 ;
74937   Dali::Toolkit::Control *argp2 ;
74938
74939   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74940   argp2 = (Dali::Toolkit::Control *)jarg2;
74941   if (!argp2) {
74942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
74943     return ;
74944   }
74945   arg2 = *argp2;
74946   if (!jarg3) {
74947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74948     return ;
74949   }
74950   std::string arg3_str(jarg3);
74951   arg3 = &arg3_str;
74952   if (!jarg4) {
74953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74954     return ;
74955   }
74956   std::string arg4_str(jarg4);
74957   arg4 = &arg4_str;
74958   {
74959     try {
74960       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
74961     } catch (std::out_of_range& e) {
74962       {
74963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74964       };
74965     } catch (std::exception& e) {
74966       {
74967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74968       };
74969     } catch (...) {
74970       {
74971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74972       };
74973     }
74974   }
74975
74976   //argout typemap for const std::string&
74977
74978
74979   //argout typemap for const std::string&
74980
74981 }
74982
74983
74984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
74985   void * jresult ;
74986   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74987   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
74988
74989   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74990   {
74991     try {
74992       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
74993     } catch (std::out_of_range& e) {
74994       {
74995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74996       };
74997     } catch (std::exception& e) {
74998       {
74999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75000       };
75001     } catch (...) {
75002       {
75003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75004       };
75005     }
75006   }
75007   jresult = (void *)result;
75008   return jresult;
75009 }
75010
75011
75012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
75013   int jresult ;
75014   int result;
75015
75016   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
75017   jresult = (int)result;
75018   return jresult;
75019 }
75020
75021
75022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
75023   int jresult ;
75024   int result;
75025
75026   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
75027   jresult = (int)result;
75028   return jresult;
75029 }
75030
75031
75032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
75033   int jresult ;
75034   int result;
75035
75036   result = (int)Dali::Toolkit::Slider::Property::VALUE;
75037   jresult = (int)result;
75038   return jresult;
75039 }
75040
75041
75042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
75043   int jresult ;
75044   int result;
75045
75046   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
75047   jresult = (int)result;
75048   return jresult;
75049 }
75050
75051
75052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
75053   int jresult ;
75054   int result;
75055
75056   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
75057   jresult = (int)result;
75058   return jresult;
75059 }
75060
75061
75062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
75063   int jresult ;
75064   int result;
75065
75066   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
75067   jresult = (int)result;
75068   return jresult;
75069 }
75070
75071
75072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
75073   int jresult ;
75074   int result;
75075
75076   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
75077   jresult = (int)result;
75078   return jresult;
75079 }
75080
75081
75082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
75083   int jresult ;
75084   int result;
75085
75086   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
75087   jresult = (int)result;
75088   return jresult;
75089 }
75090
75091
75092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
75093   int jresult ;
75094   int result;
75095
75096   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
75097   jresult = (int)result;
75098   return jresult;
75099 }
75100
75101
75102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
75103   int jresult ;
75104   int result;
75105
75106   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
75107   jresult = (int)result;
75108   return jresult;
75109 }
75110
75111
75112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
75113   int jresult ;
75114   int result;
75115
75116   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
75117   jresult = (int)result;
75118   return jresult;
75119 }
75120
75121
75122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
75123   int jresult ;
75124   int result;
75125
75126   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
75127   jresult = (int)result;
75128   return jresult;
75129 }
75130
75131
75132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
75133   int jresult ;
75134   int result;
75135
75136   result = (int)Dali::Toolkit::Slider::Property::MARKS;
75137   jresult = (int)result;
75138   return jresult;
75139 }
75140
75141
75142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
75143   int jresult ;
75144   int result;
75145
75146   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
75147   jresult = (int)result;
75148   return jresult;
75149 }
75150
75151
75152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
75153   int jresult ;
75154   int result;
75155
75156   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
75157   jresult = (int)result;
75158   return jresult;
75159 }
75160
75161
75162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
75163   void * jresult ;
75164   Dali::Toolkit::Slider::Property *result = 0 ;
75165
75166   {
75167     try {
75168       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
75169     } catch (std::out_of_range& e) {
75170       {
75171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75172       };
75173     } catch (std::exception& e) {
75174       {
75175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75176       };
75177     } catch (...) {
75178       {
75179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75180       };
75181     }
75182   }
75183   jresult = (void *)result;
75184   return jresult;
75185 }
75186
75187
75188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
75189   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
75190
75191   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
75192   {
75193     try {
75194       delete arg1;
75195     } catch (std::out_of_range& e) {
75196       {
75197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75198       };
75199     } catch (std::exception& e) {
75200       {
75201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75202       };
75203     } catch (...) {
75204       {
75205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75206       };
75207     }
75208   }
75209 }
75210
75211
75212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
75213   void * jresult ;
75214   Dali::Toolkit::Slider result;
75215
75216   {
75217     try {
75218       result = Dali::Toolkit::Slider::New();
75219     } catch (std::out_of_range& e) {
75220       {
75221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75222       };
75223     } catch (std::exception& e) {
75224       {
75225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75226       };
75227     } catch (...) {
75228       {
75229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75230       };
75231     }
75232   }
75233   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75234   return jresult;
75235 }
75236
75237
75238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
75239   void * jresult ;
75240   Dali::Toolkit::Slider *result = 0 ;
75241
75242   {
75243     try {
75244       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
75245     } catch (std::out_of_range& e) {
75246       {
75247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75248       };
75249     } catch (std::exception& e) {
75250       {
75251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75252       };
75253     } catch (...) {
75254       {
75255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75256       };
75257     }
75258   }
75259   jresult = (void *)result;
75260   return jresult;
75261 }
75262
75263
75264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
75265   void * jresult ;
75266   Dali::Toolkit::Slider *arg1 = 0 ;
75267   Dali::Toolkit::Slider *result = 0 ;
75268
75269   arg1 = (Dali::Toolkit::Slider *)jarg1;
75270   if (!arg1) {
75271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75272     return 0;
75273   }
75274   {
75275     try {
75276       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
75277     } catch (std::out_of_range& e) {
75278       {
75279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75280       };
75281     } catch (std::exception& e) {
75282       {
75283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75284       };
75285     } catch (...) {
75286       {
75287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75288       };
75289     }
75290   }
75291   jresult = (void *)result;
75292   return jresult;
75293 }
75294
75295
75296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
75297   void * jresult ;
75298   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75299   Dali::Toolkit::Slider *arg2 = 0 ;
75300   Dali::Toolkit::Slider *result = 0 ;
75301
75302   arg1 = (Dali::Toolkit::Slider *)jarg1;
75303   arg2 = (Dali::Toolkit::Slider *)jarg2;
75304   if (!arg2) {
75305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75306     return 0;
75307   }
75308   {
75309     try {
75310       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
75311     } catch (std::out_of_range& e) {
75312       {
75313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75314       };
75315     } catch (std::exception& e) {
75316       {
75317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75318       };
75319     } catch (...) {
75320       {
75321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75322       };
75323     }
75324   }
75325   jresult = (void *)result;
75326   return jresult;
75327 }
75328
75329
75330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
75331   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75332
75333   arg1 = (Dali::Toolkit::Slider *)jarg1;
75334   {
75335     try {
75336       delete arg1;
75337     } catch (std::out_of_range& e) {
75338       {
75339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75340       };
75341     } catch (std::exception& e) {
75342       {
75343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75344       };
75345     } catch (...) {
75346       {
75347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75348       };
75349     }
75350   }
75351 }
75352
75353
75354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
75355   void * jresult ;
75356   Dali::BaseHandle arg1 ;
75357   Dali::BaseHandle *argp1 ;
75358   Dali::Toolkit::Slider result;
75359
75360   argp1 = (Dali::BaseHandle *)jarg1;
75361   if (!argp1) {
75362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75363     return 0;
75364   }
75365   arg1 = *argp1;
75366   {
75367     try {
75368       result = Dali::Toolkit::Slider::DownCast(arg1);
75369     } catch (std::out_of_range& e) {
75370       {
75371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75372       };
75373     } catch (std::exception& e) {
75374       {
75375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75376       };
75377     } catch (...) {
75378       {
75379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75380       };
75381     }
75382   }
75383   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75384   return jresult;
75385 }
75386
75387
75388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
75389   void * jresult ;
75390   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75391   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75392
75393   arg1 = (Dali::Toolkit::Slider *)jarg1;
75394   {
75395     try {
75396       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
75397     } catch (std::out_of_range& e) {
75398       {
75399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75400       };
75401     } catch (std::exception& e) {
75402       {
75403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75404       };
75405     } catch (...) {
75406       {
75407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75408       };
75409     }
75410   }
75411   jresult = (void *)result;
75412   return jresult;
75413 }
75414
75415
75416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
75417   void * jresult ;
75418   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75419   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75420
75421   arg1 = (Dali::Toolkit::Slider *)jarg1;
75422   {
75423     try {
75424       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
75425     } catch (std::out_of_range& e) {
75426       {
75427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75428       };
75429     } catch (std::exception& e) {
75430       {
75431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75432       };
75433     } catch (...) {
75434       {
75435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75436       };
75437     }
75438   }
75439   jresult = (void *)result;
75440   return jresult;
75441 }
75442
75443
75444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
75445   void * jresult ;
75446   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75447   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
75448
75449   arg1 = (Dali::Toolkit::Slider *)jarg1;
75450   {
75451     try {
75452       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
75453     } catch (std::out_of_range& e) {
75454       {
75455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75456       };
75457     } catch (std::exception& e) {
75458       {
75459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75460       };
75461     } catch (...) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75464       };
75465     }
75466   }
75467   jresult = (void *)result;
75468   return jresult;
75469 }
75470
75471
75472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
75473   int jresult ;
75474   int result;
75475
75476   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
75477   jresult = (int)result;
75478   return jresult;
75479 }
75480
75481
75482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
75483   int jresult ;
75484   int result;
75485
75486   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
75487   jresult = (int)result;
75488   return jresult;
75489 }
75490
75491
75492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
75493   int jresult ;
75494   int result;
75495
75496   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
75497   jresult = (int)result;
75498   return jresult;
75499 }
75500
75501
75502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
75503   int jresult ;
75504   int result;
75505
75506   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
75507   jresult = (int)result;
75508   return jresult;
75509 }
75510
75511
75512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
75513   void * jresult ;
75514   Dali::Toolkit::VideoView::Property *result = 0 ;
75515
75516   {
75517     try {
75518       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
75519     } catch (std::out_of_range& e) {
75520       {
75521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75522       };
75523     } catch (std::exception& e) {
75524       {
75525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75526       };
75527     } catch (...) {
75528       {
75529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75530       };
75531     }
75532   }
75533   jresult = (void *)result;
75534   return jresult;
75535 }
75536
75537
75538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
75539   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
75540
75541   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
75542   {
75543     try {
75544       delete arg1;
75545     } catch (std::out_of_range& e) {
75546       {
75547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75548       };
75549     } catch (std::exception& e) {
75550       {
75551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75552       };
75553     } catch (...) {
75554       {
75555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75556       };
75557     }
75558   }
75559 }
75560
75561
75562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
75563   void * jresult ;
75564   Dali::Toolkit::VideoView result;
75565
75566   {
75567     try {
75568       result = Dali::Toolkit::VideoView::New();
75569     } catch (std::out_of_range& e) {
75570       {
75571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75572       };
75573     } catch (std::exception& e) {
75574       {
75575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75576       };
75577     } catch (...) {
75578       {
75579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75580       };
75581     }
75582   }
75583   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75584   return jresult;
75585 }
75586
75587
75588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
75589   void * jresult ;
75590   std::string *arg1 = 0 ;
75591   Dali::Toolkit::VideoView result;
75592
75593   if (!jarg1) {
75594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75595     return 0;
75596   }
75597   std::string arg1_str(jarg1);
75598   arg1 = &arg1_str;
75599   {
75600     try {
75601       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
75602     } catch (std::out_of_range& e) {
75603       {
75604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75605       };
75606     } catch (std::exception& e) {
75607       {
75608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75609       };
75610     } catch (...) {
75611       {
75612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75613       };
75614     }
75615   }
75616   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75617
75618   //argout typemap for const std::string&
75619
75620   return jresult;
75621 }
75622
75623
75624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
75625   void * jresult ;
75626   Dali::Toolkit::VideoView *result = 0 ;
75627
75628   {
75629     try {
75630       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
75631     } catch (std::out_of_range& e) {
75632       {
75633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75634       };
75635     } catch (std::exception& e) {
75636       {
75637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75638       };
75639     } catch (...) {
75640       {
75641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75642       };
75643     }
75644   }
75645   jresult = (void *)result;
75646   return jresult;
75647 }
75648
75649
75650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
75651   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75652
75653   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75654   {
75655     try {
75656       delete arg1;
75657     } catch (std::out_of_range& e) {
75658       {
75659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75660       };
75661     } catch (std::exception& e) {
75662       {
75663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75664       };
75665     } catch (...) {
75666       {
75667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75668       };
75669     }
75670   }
75671 }
75672
75673
75674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
75675   void * jresult ;
75676   Dali::Toolkit::VideoView *arg1 = 0 ;
75677   Dali::Toolkit::VideoView *result = 0 ;
75678
75679   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75680   if (!arg1) {
75681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75682     return 0;
75683   }
75684   {
75685     try {
75686       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
75687     } catch (std::out_of_range& e) {
75688       {
75689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75690       };
75691     } catch (std::exception& e) {
75692       {
75693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75694       };
75695     } catch (...) {
75696       {
75697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75698       };
75699     }
75700   }
75701   jresult = (void *)result;
75702   return jresult;
75703 }
75704
75705
75706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
75707   void * jresult ;
75708   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75709   Dali::Toolkit::VideoView *arg2 = 0 ;
75710   Dali::Toolkit::VideoView *result = 0 ;
75711
75712   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75713   arg2 = (Dali::Toolkit::VideoView *)jarg2;
75714   if (!arg2) {
75715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75716     return 0;
75717   }
75718   {
75719     try {
75720       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
75721     } catch (std::out_of_range& e) {
75722       {
75723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75724       };
75725     } catch (std::exception& e) {
75726       {
75727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75728       };
75729     } catch (...) {
75730       {
75731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75732       };
75733     }
75734   }
75735   jresult = (void *)result;
75736   return jresult;
75737 }
75738
75739
75740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
75741   void * jresult ;
75742   Dali::BaseHandle arg1 ;
75743   Dali::BaseHandle *argp1 ;
75744   Dali::Toolkit::VideoView result;
75745
75746   argp1 = (Dali::BaseHandle *)jarg1;
75747   if (!argp1) {
75748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75749     return 0;
75750   }
75751   arg1 = *argp1;
75752   {
75753     try {
75754       result = Dali::Toolkit::VideoView::DownCast(arg1);
75755     } catch (std::out_of_range& e) {
75756       {
75757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75758       };
75759     } catch (std::exception& e) {
75760       {
75761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75762       };
75763     } catch (...) {
75764       {
75765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75766       };
75767     }
75768   }
75769   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75770   return jresult;
75771 }
75772
75773
75774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
75775   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75776
75777   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75778   {
75779     try {
75780       (arg1)->Play();
75781     } catch (std::out_of_range& e) {
75782       {
75783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75784       };
75785     } catch (std::exception& e) {
75786       {
75787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75788       };
75789     } catch (...) {
75790       {
75791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75792       };
75793     }
75794   }
75795 }
75796
75797
75798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
75799   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75800
75801   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75802   {
75803     try {
75804       (arg1)->Pause();
75805     } catch (std::out_of_range& e) {
75806       {
75807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75808       };
75809     } catch (std::exception& e) {
75810       {
75811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75812       };
75813     } catch (...) {
75814       {
75815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75816       };
75817     }
75818   }
75819 }
75820
75821
75822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
75823   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75824
75825   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75826   {
75827     try {
75828       (arg1)->Stop();
75829     } catch (std::out_of_range& e) {
75830       {
75831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75832       };
75833     } catch (std::exception& e) {
75834       {
75835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75836       };
75837     } catch (...) {
75838       {
75839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75840       };
75841     }
75842   }
75843 }
75844
75845
75846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
75847   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75848   int arg2 ;
75849
75850   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75851   arg2 = (int)jarg2;
75852   {
75853     try {
75854       (arg1)->Forward(arg2);
75855     } catch (std::out_of_range& e) {
75856       {
75857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75858       };
75859     } catch (std::exception& e) {
75860       {
75861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75862       };
75863     } catch (...) {
75864       {
75865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75866       };
75867     }
75868   }
75869 }
75870
75871
75872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
75873   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75874   int arg2 ;
75875
75876   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75877   arg2 = (int)jarg2;
75878   {
75879     try {
75880       (arg1)->Backward(arg2);
75881     } catch (std::out_of_range& e) {
75882       {
75883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75884       };
75885     } catch (std::exception& e) {
75886       {
75887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75888       };
75889     } catch (...) {
75890       {
75891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75892       };
75893     }
75894   }
75895 }
75896
75897
75898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
75899   void * jresult ;
75900   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75901   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
75902
75903   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75904   {
75905     try {
75906       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
75907     } catch (std::out_of_range& e) {
75908       {
75909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75910       };
75911     } catch (std::exception& e) {
75912       {
75913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75914       };
75915     } catch (...) {
75916       {
75917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75918       };
75919     }
75920   }
75921   jresult = (void *)result;
75922   return jresult;
75923 }
75924
75925
75926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
75927   int jresult ;
75928   int result;
75929
75930   result = (int)Dali::Toolkit::Popup::Property::TITLE;
75931   jresult = (int)result;
75932   return jresult;
75933 }
75934
75935
75936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
75937   int jresult ;
75938   int result;
75939
75940   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
75941   jresult = (int)result;
75942   return jresult;
75943 }
75944
75945
75946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
75947   int jresult ;
75948   int result;
75949
75950   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
75951   jresult = (int)result;
75952   return jresult;
75953 }
75954
75955
75956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
75957   int jresult ;
75958   int result;
75959
75960   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
75961   jresult = (int)result;
75962   return jresult;
75963 }
75964
75965
75966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
75967   int jresult ;
75968   int result;
75969
75970   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
75971   jresult = (int)result;
75972   return jresult;
75973 }
75974
75975
75976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
75977   int jresult ;
75978   int result;
75979
75980   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
75981   jresult = (int)result;
75982   return jresult;
75983 }
75984
75985
75986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
75987   int jresult ;
75988   int result;
75989
75990   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
75991   jresult = (int)result;
75992   return jresult;
75993 }
75994
75995
75996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
75997   int jresult ;
75998   int result;
75999
76000   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
76001   jresult = (int)result;
76002   return jresult;
76003 }
76004
76005
76006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
76007   int jresult ;
76008   int result;
76009
76010   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
76011   jresult = (int)result;
76012   return jresult;
76013 }
76014
76015
76016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
76017   int jresult ;
76018   int result;
76019
76020   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
76021   jresult = (int)result;
76022   return jresult;
76023 }
76024
76025
76026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
76027   int jresult ;
76028   int result;
76029
76030   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
76031   jresult = (int)result;
76032   return jresult;
76033 }
76034
76035
76036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
76037   int jresult ;
76038   int result;
76039
76040   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
76041   jresult = (int)result;
76042   return jresult;
76043 }
76044
76045
76046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
76047   int jresult ;
76048   int result;
76049
76050   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
76051   jresult = (int)result;
76052   return jresult;
76053 }
76054
76055
76056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
76057   int jresult ;
76058   int result;
76059
76060   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
76061   jresult = (int)result;
76062   return jresult;
76063 }
76064
76065
76066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
76067   int jresult ;
76068   int result;
76069
76070   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
76071   jresult = (int)result;
76072   return jresult;
76073 }
76074
76075
76076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
76077   int jresult ;
76078   int result;
76079
76080   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
76081   jresult = (int)result;
76082   return jresult;
76083 }
76084
76085
76086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
76087   int jresult ;
76088   int result;
76089
76090   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
76091   jresult = (int)result;
76092   return jresult;
76093 }
76094
76095
76096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
76097   int jresult ;
76098   int result;
76099
76100   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
76101   jresult = (int)result;
76102   return jresult;
76103 }
76104
76105
76106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
76107   int jresult ;
76108   int result;
76109
76110   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
76111   jresult = (int)result;
76112   return jresult;
76113 }
76114
76115
76116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
76117   int jresult ;
76118   int result;
76119
76120   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
76121   jresult = (int)result;
76122   return jresult;
76123 }
76124
76125
76126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
76127   int jresult ;
76128   int result;
76129
76130   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
76131   jresult = (int)result;
76132   return jresult;
76133 }
76134
76135
76136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
76137   void * jresult ;
76138   Dali::Toolkit::Popup::Property *result = 0 ;
76139
76140   {
76141     try {
76142       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
76143     } catch (std::out_of_range& e) {
76144       {
76145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76146       };
76147     } catch (std::exception& e) {
76148       {
76149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76150       };
76151     } catch (...) {
76152       {
76153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76154       };
76155     }
76156   }
76157   jresult = (void *)result;
76158   return jresult;
76159 }
76160
76161
76162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
76163   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
76164
76165   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
76166   {
76167     try {
76168       delete arg1;
76169     } catch (std::out_of_range& e) {
76170       {
76171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76172       };
76173     } catch (std::exception& e) {
76174       {
76175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76176       };
76177     } catch (...) {
76178       {
76179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76180       };
76181     }
76182   }
76183 }
76184
76185
76186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
76187   void * jresult ;
76188   Dali::Toolkit::Popup *result = 0 ;
76189
76190   {
76191     try {
76192       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
76193     } catch (std::out_of_range& e) {
76194       {
76195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76196       };
76197     } catch (std::exception& e) {
76198       {
76199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76200       };
76201     } catch (...) {
76202       {
76203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76204       };
76205     }
76206   }
76207   jresult = (void *)result;
76208   return jresult;
76209 }
76210
76211
76212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
76213   void * jresult ;
76214   Dali::Toolkit::Popup result;
76215
76216   {
76217     try {
76218       result = Dali::Toolkit::Popup::New();
76219     } catch (std::out_of_range& e) {
76220       {
76221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76222       };
76223     } catch (std::exception& e) {
76224       {
76225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76226       };
76227     } catch (...) {
76228       {
76229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76230       };
76231     }
76232   }
76233   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76234   return jresult;
76235 }
76236
76237
76238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
76239   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76240
76241   arg1 = (Dali::Toolkit::Popup *)jarg1;
76242   {
76243     try {
76244       delete arg1;
76245     } catch (std::out_of_range& e) {
76246       {
76247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76248       };
76249     } catch (std::exception& e) {
76250       {
76251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76252       };
76253     } catch (...) {
76254       {
76255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76256       };
76257     }
76258   }
76259 }
76260
76261
76262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
76263   void * jresult ;
76264   Dali::Toolkit::Popup *arg1 = 0 ;
76265   Dali::Toolkit::Popup *result = 0 ;
76266
76267   arg1 = (Dali::Toolkit::Popup *)jarg1;
76268   if (!arg1) {
76269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76270     return 0;
76271   }
76272   {
76273     try {
76274       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
76275     } catch (std::out_of_range& e) {
76276       {
76277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76278       };
76279     } catch (std::exception& e) {
76280       {
76281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76282       };
76283     } catch (...) {
76284       {
76285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76286       };
76287     }
76288   }
76289   jresult = (void *)result;
76290   return jresult;
76291 }
76292
76293
76294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
76295   void * jresult ;
76296   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76297   Dali::Toolkit::Popup *arg2 = 0 ;
76298   Dali::Toolkit::Popup *result = 0 ;
76299
76300   arg1 = (Dali::Toolkit::Popup *)jarg1;
76301   arg2 = (Dali::Toolkit::Popup *)jarg2;
76302   if (!arg2) {
76303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76304     return 0;
76305   }
76306   {
76307     try {
76308       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
76309     } catch (std::out_of_range& e) {
76310       {
76311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76312       };
76313     } catch (std::exception& e) {
76314       {
76315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76316       };
76317     } catch (...) {
76318       {
76319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76320       };
76321     }
76322   }
76323   jresult = (void *)result;
76324   return jresult;
76325 }
76326
76327
76328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
76329   void * jresult ;
76330   Dali::BaseHandle arg1 ;
76331   Dali::BaseHandle *argp1 ;
76332   Dali::Toolkit::Popup result;
76333
76334   argp1 = (Dali::BaseHandle *)jarg1;
76335   if (!argp1) {
76336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76337     return 0;
76338   }
76339   arg1 = *argp1;
76340   {
76341     try {
76342       result = Dali::Toolkit::Popup::DownCast(arg1);
76343     } catch (std::out_of_range& e) {
76344       {
76345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76346       };
76347     } catch (std::exception& e) {
76348       {
76349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76350       };
76351     } catch (...) {
76352       {
76353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76354       };
76355     }
76356   }
76357   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76358   return jresult;
76359 }
76360
76361
76362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
76363   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76364   Dali::Actor arg2 ;
76365   Dali::Actor *argp2 ;
76366
76367   arg1 = (Dali::Toolkit::Popup *)jarg1;
76368   argp2 = (Dali::Actor *)jarg2;
76369   if (!argp2) {
76370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76371     return ;
76372   }
76373   arg2 = *argp2;
76374   {
76375     try {
76376       (arg1)->SetTitle(arg2);
76377     } catch (std::out_of_range& e) {
76378       {
76379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76380       };
76381     } catch (std::exception& e) {
76382       {
76383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76384       };
76385     } catch (...) {
76386       {
76387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76388       };
76389     }
76390   }
76391 }
76392
76393
76394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
76395   void * jresult ;
76396   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76397   Dali::Actor result;
76398
76399   arg1 = (Dali::Toolkit::Popup *)jarg1;
76400   {
76401     try {
76402       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
76403     } catch (std::out_of_range& e) {
76404       {
76405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76406       };
76407     } catch (std::exception& e) {
76408       {
76409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76410       };
76411     } catch (...) {
76412       {
76413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76414       };
76415     }
76416   }
76417   jresult = new Dali::Actor((const Dali::Actor &)result);
76418   return jresult;
76419 }
76420
76421
76422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
76423   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76424   Dali::Actor arg2 ;
76425   Dali::Actor *argp2 ;
76426
76427   arg1 = (Dali::Toolkit::Popup *)jarg1;
76428   argp2 = (Dali::Actor *)jarg2;
76429   if (!argp2) {
76430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76431     return ;
76432   }
76433   arg2 = *argp2;
76434   {
76435     try {
76436       (arg1)->SetContent(arg2);
76437     } catch (std::out_of_range& e) {
76438       {
76439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76440       };
76441     } catch (std::exception& e) {
76442       {
76443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76444       };
76445     } catch (...) {
76446       {
76447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76448       };
76449     }
76450   }
76451 }
76452
76453
76454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
76455   void * jresult ;
76456   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76457   Dali::Actor result;
76458
76459   arg1 = (Dali::Toolkit::Popup *)jarg1;
76460   {
76461     try {
76462       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
76463     } catch (std::out_of_range& e) {
76464       {
76465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76466       };
76467     } catch (std::exception& e) {
76468       {
76469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76470       };
76471     } catch (...) {
76472       {
76473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76474       };
76475     }
76476   }
76477   jresult = new Dali::Actor((const Dali::Actor &)result);
76478   return jresult;
76479 }
76480
76481
76482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
76483   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76484   Dali::Actor arg2 ;
76485   Dali::Actor *argp2 ;
76486
76487   arg1 = (Dali::Toolkit::Popup *)jarg1;
76488   argp2 = (Dali::Actor *)jarg2;
76489   if (!argp2) {
76490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76491     return ;
76492   }
76493   arg2 = *argp2;
76494   {
76495     try {
76496       (arg1)->SetFooter(arg2);
76497     } catch (std::out_of_range& e) {
76498       {
76499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76500       };
76501     } catch (std::exception& e) {
76502       {
76503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76504       };
76505     } catch (...) {
76506       {
76507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76508       };
76509     }
76510   }
76511 }
76512
76513
76514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
76515   void * jresult ;
76516   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76517   Dali::Actor result;
76518
76519   arg1 = (Dali::Toolkit::Popup *)jarg1;
76520   {
76521     try {
76522       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
76523     } catch (std::out_of_range& e) {
76524       {
76525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76526       };
76527     } catch (std::exception& e) {
76528       {
76529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76530       };
76531     } catch (...) {
76532       {
76533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76534       };
76535     }
76536   }
76537   jresult = new Dali::Actor((const Dali::Actor &)result);
76538   return jresult;
76539 }
76540
76541
76542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
76543   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76544   Dali::Toolkit::Popup::DisplayState arg2 ;
76545
76546   arg1 = (Dali::Toolkit::Popup *)jarg1;
76547   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
76548   {
76549     try {
76550       (arg1)->SetDisplayState(arg2);
76551     } catch (std::out_of_range& e) {
76552       {
76553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76554       };
76555     } catch (std::exception& e) {
76556       {
76557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76558       };
76559     } catch (...) {
76560       {
76561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76562       };
76563     }
76564   }
76565 }
76566
76567
76568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
76569   int jresult ;
76570   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76571   Dali::Toolkit::Popup::DisplayState result;
76572
76573   arg1 = (Dali::Toolkit::Popup *)jarg1;
76574   {
76575     try {
76576       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
76577     } catch (std::out_of_range& e) {
76578       {
76579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76580       };
76581     } catch (std::exception& e) {
76582       {
76583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76584       };
76585     } catch (...) {
76586       {
76587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76588       };
76589     }
76590   }
76591   jresult = (int)result;
76592   return jresult;
76593 }
76594
76595
76596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
76597   void * jresult ;
76598   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76599   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
76600
76601   arg1 = (Dali::Toolkit::Popup *)jarg1;
76602   {
76603     try {
76604       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
76605     } catch (std::out_of_range& e) {
76606       {
76607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76608       };
76609     } catch (std::exception& e) {
76610       {
76611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76612       };
76613     } catch (...) {
76614       {
76615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76616       };
76617     }
76618   }
76619   jresult = (void *)result;
76620   return jresult;
76621 }
76622
76623
76624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
76625   void * jresult ;
76626   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76627   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76628
76629   arg1 = (Dali::Toolkit::Popup *)jarg1;
76630   {
76631     try {
76632       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
76633     } catch (std::out_of_range& e) {
76634       {
76635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76636       };
76637     } catch (std::exception& e) {
76638       {
76639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76640       };
76641     } catch (...) {
76642       {
76643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76644       };
76645     }
76646   }
76647   jresult = (void *)result;
76648   return jresult;
76649 }
76650
76651
76652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
76653   void * jresult ;
76654   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76655   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76656
76657   arg1 = (Dali::Toolkit::Popup *)jarg1;
76658   {
76659     try {
76660       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
76661     } catch (std::out_of_range& e) {
76662       {
76663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76664       };
76665     } catch (std::exception& e) {
76666       {
76667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76668       };
76669     } catch (...) {
76670       {
76671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76672       };
76673     }
76674   }
76675   jresult = (void *)result;
76676   return jresult;
76677 }
76678
76679
76680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
76681   void * jresult ;
76682   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76683   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76684
76685   arg1 = (Dali::Toolkit::Popup *)jarg1;
76686   {
76687     try {
76688       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
76689     } catch (std::out_of_range& e) {
76690       {
76691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76692       };
76693     } catch (std::exception& e) {
76694       {
76695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76696       };
76697     } catch (...) {
76698       {
76699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76700       };
76701     }
76702   }
76703   jresult = (void *)result;
76704   return jresult;
76705 }
76706
76707
76708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
76709   void * jresult ;
76710   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76711   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76712
76713   arg1 = (Dali::Toolkit::Popup *)jarg1;
76714   {
76715     try {
76716       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
76717     } catch (std::out_of_range& e) {
76718       {
76719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76720       };
76721     } catch (std::exception& e) {
76722       {
76723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76724       };
76725     } catch (...) {
76726       {
76727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76728       };
76729     }
76730   }
76731   jresult = (void *)result;
76732   return jresult;
76733 }
76734
76735
76736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
76737   int jresult ;
76738   int result;
76739
76740   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
76741   jresult = (int)result;
76742   return jresult;
76743 }
76744
76745
76746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
76747   int jresult ;
76748   int result;
76749
76750   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
76751   jresult = (int)result;
76752   return jresult;
76753 }
76754
76755
76756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
76757   int jresult ;
76758   int result;
76759
76760   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
76761   jresult = (int)result;
76762   return jresult;
76763 }
76764
76765
76766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
76767   int jresult ;
76768   int result;
76769
76770   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
76771   jresult = (int)result;
76772   return jresult;
76773 }
76774
76775
76776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
76777   int jresult ;
76778   int result;
76779
76780   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
76781   jresult = (int)result;
76782   return jresult;
76783 }
76784
76785
76786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
76787   int jresult ;
76788   int result;
76789
76790   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
76791   jresult = (int)result;
76792   return jresult;
76793 }
76794
76795
76796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
76797   int jresult ;
76798   int result;
76799
76800   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
76801   jresult = (int)result;
76802   return jresult;
76803 }
76804
76805
76806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
76807   int jresult ;
76808   int result;
76809
76810   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
76811   jresult = (int)result;
76812   return jresult;
76813 }
76814
76815
76816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
76817   int jresult ;
76818   int result;
76819
76820   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
76821   jresult = (int)result;
76822   return jresult;
76823 }
76824
76825
76826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
76827   void * jresult ;
76828   Dali::Toolkit::ProgressBar::Property *result = 0 ;
76829
76830   {
76831     try {
76832       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
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_delete_ProgressBar_Property(void * jarg1) {
76853   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
76854
76855   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
76856   {
76857     try {
76858       delete arg1;
76859     } catch (std::out_of_range& e) {
76860       {
76861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76862       };
76863     } catch (std::exception& e) {
76864       {
76865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76866       };
76867     } catch (...) {
76868       {
76869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76870       };
76871     }
76872   }
76873 }
76874
76875
76876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
76877   void * jresult ;
76878   Dali::Toolkit::ProgressBar result;
76879
76880   {
76881     try {
76882       result = Dali::Toolkit::ProgressBar::New();
76883     } catch (std::out_of_range& e) {
76884       {
76885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76886       };
76887     } catch (std::exception& e) {
76888       {
76889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76890       };
76891     } catch (...) {
76892       {
76893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76894       };
76895     }
76896   }
76897   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
76898   return jresult;
76899 }
76900
76901
76902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
76903   void * jresult ;
76904   Dali::Toolkit::ProgressBar *result = 0 ;
76905
76906   {
76907     try {
76908       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
76909     } catch (std::out_of_range& e) {
76910       {
76911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76912       };
76913     } catch (std::exception& e) {
76914       {
76915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76916       };
76917     } catch (...) {
76918       {
76919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76920       };
76921     }
76922   }
76923   jresult = (void *)result;
76924   return jresult;
76925 }
76926
76927
76928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
76929   void * jresult ;
76930   Dali::Toolkit::ProgressBar *arg1 = 0 ;
76931   Dali::Toolkit::ProgressBar *result = 0 ;
76932
76933   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76934   if (!arg1) {
76935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76936     return 0;
76937   }
76938   {
76939     try {
76940       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
76941     } catch (std::out_of_range& e) {
76942       {
76943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76944       };
76945     } catch (std::exception& e) {
76946       {
76947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76948       };
76949     } catch (...) {
76950       {
76951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76952       };
76953     }
76954   }
76955   jresult = (void *)result;
76956   return jresult;
76957 }
76958
76959
76960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
76961   void * jresult ;
76962   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76963   Dali::Toolkit::ProgressBar *arg2 = 0 ;
76964   Dali::Toolkit::ProgressBar *result = 0 ;
76965
76966   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76967   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
76968   if (!arg2) {
76969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
76970     return 0;
76971   }
76972   {
76973     try {
76974       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
76975     } catch (std::out_of_range& e) {
76976       {
76977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76978       };
76979     } catch (std::exception& e) {
76980       {
76981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76982       };
76983     } catch (...) {
76984       {
76985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76986       };
76987     }
76988   }
76989   jresult = (void *)result;
76990   return jresult;
76991 }
76992
76993
76994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
76995   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
76996
76997   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
76998   {
76999     try {
77000       delete arg1;
77001     } catch (std::out_of_range& e) {
77002       {
77003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77004       };
77005     } catch (std::exception& e) {
77006       {
77007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77008       };
77009     } catch (...) {
77010       {
77011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77012       };
77013     }
77014   }
77015 }
77016
77017
77018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
77019   void * jresult ;
77020   Dali::BaseHandle arg1 ;
77021   Dali::BaseHandle *argp1 ;
77022   Dali::Toolkit::ProgressBar result;
77023
77024   argp1 = (Dali::BaseHandle *)jarg1;
77025   if (!argp1) {
77026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77027     return 0;
77028   }
77029   arg1 = *argp1;
77030   {
77031     try {
77032       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
77033     } catch (std::out_of_range& e) {
77034       {
77035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77036       };
77037     } catch (std::exception& e) {
77038       {
77039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77040       };
77041     } catch (...) {
77042       {
77043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77044       };
77045     }
77046   }
77047   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
77048   return jresult;
77049 }
77050
77051
77052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
77053   void * jresult ;
77054   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77055   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
77056
77057   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77058   {
77059     try {
77060       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77061     } catch (std::out_of_range& e) {
77062       {
77063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77064       };
77065     } catch (std::exception& e) {
77066       {
77067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77068       };
77069     } catch (...) {
77070       {
77071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77072       };
77073     }
77074   }
77075   jresult = (void *)result;
77076   return jresult;
77077 }
77078
77079
77080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
77081   void * jresult ;
77082   Dali::Toolkit::GaussianBlurView *result = 0 ;
77083
77084   {
77085     try {
77086       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
77087     } catch (std::out_of_range& e) {
77088       {
77089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77090       };
77091     } catch (std::exception& e) {
77092       {
77093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77094       };
77095     } catch (...) {
77096       {
77097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77098       };
77099     }
77100   }
77101   jresult = (void *)result;
77102   return jresult;
77103 }
77104
77105
77106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
77107   void * jresult ;
77108   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
77109   Dali::Toolkit::GaussianBlurView *result = 0 ;
77110
77111   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77112   if (!arg1) {
77113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77114     return 0;
77115   }
77116   {
77117     try {
77118       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
77119     } catch (std::out_of_range& e) {
77120       {
77121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77122       };
77123     } catch (std::exception& e) {
77124       {
77125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77126       };
77127     } catch (...) {
77128       {
77129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77130       };
77131     }
77132   }
77133   jresult = (void *)result;
77134   return jresult;
77135 }
77136
77137
77138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
77139   void * jresult ;
77140   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77141   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
77142   Dali::Toolkit::GaussianBlurView *result = 0 ;
77143
77144   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77145   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
77146   if (!arg2) {
77147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77148     return 0;
77149   }
77150   {
77151     try {
77152       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
77153     } catch (std::out_of_range& e) {
77154       {
77155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77156       };
77157     } catch (std::exception& e) {
77158       {
77159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77160       };
77161     } catch (...) {
77162       {
77163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77164       };
77165     }
77166   }
77167   jresult = (void *)result;
77168   return jresult;
77169 }
77170
77171
77172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
77173   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77174
77175   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77176   {
77177     try {
77178       delete arg1;
77179     } catch (std::out_of_range& e) {
77180       {
77181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77182       };
77183     } catch (std::exception& e) {
77184       {
77185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77186       };
77187     } catch (...) {
77188       {
77189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77190       };
77191     }
77192   }
77193 }
77194
77195
77196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
77197   void * jresult ;
77198   Dali::BaseHandle arg1 ;
77199   Dali::BaseHandle *argp1 ;
77200   Dali::Toolkit::GaussianBlurView result;
77201
77202   argp1 = (Dali::BaseHandle *)jarg1;
77203   if (!argp1) {
77204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77205     return 0;
77206   }
77207   arg1 = *argp1;
77208   {
77209     try {
77210       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
77211     } catch (std::out_of_range& e) {
77212       {
77213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77214       };
77215     } catch (std::exception& e) {
77216       {
77217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77218       };
77219     } catch (...) {
77220       {
77221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77222       };
77223     }
77224   }
77225   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77226   return jresult;
77227 }
77228
77229
77230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
77231   void * jresult ;
77232   Dali::Toolkit::GaussianBlurView result;
77233
77234   {
77235     try {
77236       result = Dali::Toolkit::GaussianBlurView::New();
77237     } catch (std::out_of_range& e) {
77238       {
77239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77240       };
77241     } catch (std::exception& e) {
77242       {
77243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77244       };
77245     } catch (...) {
77246       {
77247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77248       };
77249     }
77250   }
77251   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77252   return jresult;
77253 }
77254
77255
77256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
77257   void * jresult ;
77258   unsigned int arg1 ;
77259   float arg2 ;
77260   Dali::Pixel::Format arg3 ;
77261   float arg4 ;
77262   float arg5 ;
77263   bool arg6 ;
77264   Dali::Toolkit::GaussianBlurView result;
77265
77266   arg1 = (unsigned int)jarg1;
77267   arg2 = (float)jarg2;
77268   arg3 = (Dali::Pixel::Format)jarg3;
77269   arg4 = (float)jarg4;
77270   arg5 = (float)jarg5;
77271   arg6 = jarg6 ? true : false;
77272   {
77273     try {
77274       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
77275     } catch (std::out_of_range& e) {
77276       {
77277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77278       };
77279     } catch (std::exception& e) {
77280       {
77281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77282       };
77283     } catch (...) {
77284       {
77285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77286       };
77287     }
77288   }
77289   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77290   return jresult;
77291 }
77292
77293
77294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
77295   void * jresult ;
77296   unsigned int arg1 ;
77297   float arg2 ;
77298   Dali::Pixel::Format arg3 ;
77299   float arg4 ;
77300   float arg5 ;
77301   Dali::Toolkit::GaussianBlurView result;
77302
77303   arg1 = (unsigned int)jarg1;
77304   arg2 = (float)jarg2;
77305   arg3 = (Dali::Pixel::Format)jarg3;
77306   arg4 = (float)jarg4;
77307   arg5 = (float)jarg5;
77308   {
77309     try {
77310       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
77311     } catch (std::out_of_range& e) {
77312       {
77313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77314       };
77315     } catch (std::exception& e) {
77316       {
77317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77318       };
77319     } catch (...) {
77320       {
77321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77322       };
77323     }
77324   }
77325   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77326   return jresult;
77327 }
77328
77329
77330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
77331   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77332   Dali::Actor arg2 ;
77333   Dali::Actor *argp2 ;
77334
77335   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77336   argp2 = (Dali::Actor *)jarg2;
77337   if (!argp2) {
77338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77339     return ;
77340   }
77341   arg2 = *argp2;
77342   {
77343     try {
77344       (arg1)->Add(arg2);
77345     } catch (std::out_of_range& e) {
77346       {
77347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77348       };
77349     } catch (std::exception& e) {
77350       {
77351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77352       };
77353     } catch (...) {
77354       {
77355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77356       };
77357     }
77358   }
77359 }
77360
77361
77362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
77363   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77364   Dali::Actor arg2 ;
77365   Dali::Actor *argp2 ;
77366
77367   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77368   argp2 = (Dali::Actor *)jarg2;
77369   if (!argp2) {
77370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77371     return ;
77372   }
77373   arg2 = *argp2;
77374   {
77375     try {
77376       (arg1)->Remove(arg2);
77377     } catch (std::out_of_range& e) {
77378       {
77379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77380       };
77381     } catch (std::exception& e) {
77382       {
77383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77384       };
77385     } catch (...) {
77386       {
77387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77388       };
77389     }
77390   }
77391 }
77392
77393
77394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
77395   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77396
77397   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77398   {
77399     try {
77400       (arg1)->Activate();
77401     } catch (std::out_of_range& e) {
77402       {
77403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77404       };
77405     } catch (std::exception& e) {
77406       {
77407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77408       };
77409     } catch (...) {
77410       {
77411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77412       };
77413     }
77414   }
77415 }
77416
77417
77418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
77419   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77420
77421   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77422   {
77423     try {
77424       (arg1)->ActivateOnce();
77425     } catch (std::out_of_range& e) {
77426       {
77427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77428       };
77429     } catch (std::exception& e) {
77430       {
77431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77432       };
77433     } catch (...) {
77434       {
77435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77436       };
77437     }
77438   }
77439 }
77440
77441
77442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
77443   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77444
77445   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77446   {
77447     try {
77448       (arg1)->Deactivate();
77449     } catch (std::out_of_range& e) {
77450       {
77451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77452       };
77453     } catch (std::exception& e) {
77454       {
77455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77456       };
77457     } catch (...) {
77458       {
77459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77460       };
77461     }
77462   }
77463 }
77464
77465
77466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
77467   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77468   Dali::Image arg2 ;
77469   Dali::FrameBufferImage arg3 ;
77470   Dali::Image *argp2 ;
77471   Dali::FrameBufferImage *argp3 ;
77472
77473   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77474   argp2 = (Dali::Image *)jarg2;
77475   if (!argp2) {
77476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
77477     return ;
77478   }
77479   arg2 = *argp2;
77480   argp3 = (Dali::FrameBufferImage *)jarg3;
77481   if (!argp3) {
77482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
77483     return ;
77484   }
77485   arg3 = *argp3;
77486   {
77487     try {
77488       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
77489     } catch (std::out_of_range& e) {
77490       {
77491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77492       };
77493     } catch (std::exception& e) {
77494       {
77495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77496       };
77497     } catch (...) {
77498       {
77499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77500       };
77501     }
77502   }
77503 }
77504
77505
77506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
77507   int jresult ;
77508   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77509   Dali::Property::Index result;
77510
77511   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77512   {
77513     try {
77514       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
77515     } catch (std::out_of_range& e) {
77516       {
77517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77518       };
77519     } catch (std::exception& e) {
77520       {
77521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77522       };
77523     } catch (...) {
77524       {
77525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77526       };
77527     }
77528   }
77529   jresult = result;
77530   return jresult;
77531 }
77532
77533
77534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
77535   void * jresult ;
77536   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77537   Dali::FrameBufferImage result;
77538
77539   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77540   {
77541     try {
77542       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
77543     } catch (std::out_of_range& e) {
77544       {
77545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77546       };
77547     } catch (std::exception& e) {
77548       {
77549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77550       };
77551     } catch (...) {
77552       {
77553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77554       };
77555     }
77556   }
77557   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
77558   return jresult;
77559 }
77560
77561
77562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
77563   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77564   Dali::Vector4 *arg2 = 0 ;
77565
77566   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77567   arg2 = (Dali::Vector4 *)jarg2;
77568   if (!arg2) {
77569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
77570     return ;
77571   }
77572   {
77573     try {
77574       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
77575     } catch (std::out_of_range& e) {
77576       {
77577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77578       };
77579     } catch (std::exception& e) {
77580       {
77581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77582       };
77583     } catch (...) {
77584       {
77585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77586       };
77587     }
77588   }
77589 }
77590
77591
77592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
77593   void * jresult ;
77594   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77595   Dali::Vector4 result;
77596
77597   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77598   {
77599     try {
77600       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
77601     } catch (std::out_of_range& e) {
77602       {
77603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77604       };
77605     } catch (std::exception& e) {
77606       {
77607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77608       };
77609     } catch (...) {
77610       {
77611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77612       };
77613     }
77614   }
77615   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
77616   return jresult;
77617 }
77618
77619
77620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
77621   void * jresult ;
77622   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77623   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
77624
77625   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77626   {
77627     try {
77628       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
77629     } catch (std::out_of_range& e) {
77630       {
77631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77632       };
77633     } catch (std::exception& e) {
77634       {
77635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77636       };
77637     } catch (...) {
77638       {
77639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77640       };
77641     }
77642   }
77643   jresult = (void *)result;
77644   return jresult;
77645 }
77646
77647
77648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
77649   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77650
77651   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77652   {
77653     try {
77654       delete arg1;
77655     } catch (std::out_of_range& e) {
77656       {
77657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77658       };
77659     } catch (std::exception& e) {
77660       {
77661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77662       };
77663     } catch (...) {
77664       {
77665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77666       };
77667     }
77668   }
77669 }
77670
77671
77672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
77673   unsigned int jresult ;
77674   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77675   unsigned int result;
77676
77677   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77678   {
77679     try {
77680       result = (unsigned int)(arg1)->GetNumberOfPages();
77681     } catch (std::out_of_range& e) {
77682       {
77683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77684       };
77685     } catch (std::exception& e) {
77686       {
77687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77688       };
77689     } catch (...) {
77690       {
77691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77692       };
77693     }
77694   }
77695   jresult = result;
77696   return jresult;
77697 }
77698
77699
77700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
77701   void * jresult ;
77702   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77703   unsigned int arg2 ;
77704   Dali::Texture result;
77705
77706   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77707   arg2 = (unsigned int)jarg2;
77708   {
77709     try {
77710       result = (arg1)->NewPage(arg2);
77711     } catch (std::out_of_range& e) {
77712       {
77713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77714       };
77715     } catch (std::exception& e) {
77716       {
77717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77718       };
77719     } catch (...) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77722       };
77723     }
77724   }
77725   jresult = new Dali::Texture((const Dali::Texture &)result);
77726   return jresult;
77727 }
77728
77729
77730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
77731   int jresult ;
77732   int result;
77733
77734   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
77735   jresult = (int)result;
77736   return jresult;
77737 }
77738
77739
77740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
77741   int jresult ;
77742   int result;
77743
77744   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
77745   jresult = (int)result;
77746   return jresult;
77747 }
77748
77749
77750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
77751   int jresult ;
77752   int result;
77753
77754   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
77755   jresult = (int)result;
77756   return jresult;
77757 }
77758
77759
77760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
77761   void * jresult ;
77762   Dali::Toolkit::PageTurnView::Property *result = 0 ;
77763
77764   {
77765     try {
77766       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
77767     } catch (std::out_of_range& e) {
77768       {
77769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77770       };
77771     } catch (std::exception& e) {
77772       {
77773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77774       };
77775     } catch (...) {
77776       {
77777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77778       };
77779     }
77780   }
77781   jresult = (void *)result;
77782   return jresult;
77783 }
77784
77785
77786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
77787   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
77788
77789   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
77790   {
77791     try {
77792       delete arg1;
77793     } catch (std::out_of_range& e) {
77794       {
77795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77796       };
77797     } catch (std::exception& e) {
77798       {
77799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77800       };
77801     } catch (...) {
77802       {
77803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77804       };
77805     }
77806   }
77807 }
77808
77809
77810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
77811   void * jresult ;
77812   Dali::Toolkit::PageTurnView *result = 0 ;
77813
77814   {
77815     try {
77816       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
77817     } catch (std::out_of_range& e) {
77818       {
77819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77820       };
77821     } catch (std::exception& e) {
77822       {
77823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77824       };
77825     } catch (...) {
77826       {
77827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77828       };
77829     }
77830   }
77831   jresult = (void *)result;
77832   return jresult;
77833 }
77834
77835
77836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
77837   void * jresult ;
77838   Dali::Toolkit::PageTurnView *arg1 = 0 ;
77839   Dali::Toolkit::PageTurnView *result = 0 ;
77840
77841   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77842   if (!arg1) {
77843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77844     return 0;
77845   }
77846   {
77847     try {
77848       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
77849     } catch (std::out_of_range& e) {
77850       {
77851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77852       };
77853     } catch (std::exception& e) {
77854       {
77855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77856       };
77857     } catch (...) {
77858       {
77859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77860       };
77861     }
77862   }
77863   jresult = (void *)result;
77864   return jresult;
77865 }
77866
77867
77868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
77869   void * jresult ;
77870   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77871   Dali::Toolkit::PageTurnView *arg2 = 0 ;
77872   Dali::Toolkit::PageTurnView *result = 0 ;
77873
77874   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77875   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
77876   if (!arg2) {
77877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77878     return 0;
77879   }
77880   {
77881     try {
77882       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
77883     } catch (std::out_of_range& e) {
77884       {
77885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77886       };
77887     } catch (std::exception& e) {
77888       {
77889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77890       };
77891     } catch (...) {
77892       {
77893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77894       };
77895     }
77896   }
77897   jresult = (void *)result;
77898   return jresult;
77899 }
77900
77901
77902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
77903   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77904
77905   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77906   {
77907     try {
77908       delete arg1;
77909     } catch (std::out_of_range& e) {
77910       {
77911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77912       };
77913     } catch (std::exception& e) {
77914       {
77915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77916       };
77917     } catch (...) {
77918       {
77919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77920       };
77921     }
77922   }
77923 }
77924
77925
77926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
77927   void * jresult ;
77928   Dali::BaseHandle arg1 ;
77929   Dali::BaseHandle *argp1 ;
77930   Dali::Toolkit::PageTurnView result;
77931
77932   argp1 = (Dali::BaseHandle *)jarg1;
77933   if (!argp1) {
77934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77935     return 0;
77936   }
77937   arg1 = *argp1;
77938   {
77939     try {
77940       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
77941     } catch (std::out_of_range& e) {
77942       {
77943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77944       };
77945     } catch (std::exception& e) {
77946       {
77947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77948       };
77949     } catch (...) {
77950       {
77951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77952       };
77953     }
77954   }
77955   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
77956   return jresult;
77957 }
77958
77959
77960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
77961   void * jresult ;
77962   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77963   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77964
77965   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77966   {
77967     try {
77968       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
77969     } catch (std::out_of_range& e) {
77970       {
77971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77972       };
77973     } catch (std::exception& e) {
77974       {
77975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77976       };
77977     } catch (...) {
77978       {
77979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77980       };
77981     }
77982   }
77983   jresult = (void *)result;
77984   return jresult;
77985 }
77986
77987
77988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
77989   void * jresult ;
77990   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
77991   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
77992
77993   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77994   {
77995     try {
77996       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
77997     } catch (std::out_of_range& e) {
77998       {
77999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78000       };
78001     } catch (std::exception& e) {
78002       {
78003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78004       };
78005     } catch (...) {
78006       {
78007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78008       };
78009     }
78010   }
78011   jresult = (void *)result;
78012   return jresult;
78013 }
78014
78015
78016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
78017   void * jresult ;
78018   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78019   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78020
78021   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78022   {
78023     try {
78024       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
78025     } catch (std::out_of_range& e) {
78026       {
78027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78028       };
78029     } catch (std::exception& e) {
78030       {
78031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78032       };
78033     } catch (...) {
78034       {
78035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78036       };
78037     }
78038   }
78039   jresult = (void *)result;
78040   return jresult;
78041 }
78042
78043
78044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
78045   void * jresult ;
78046   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78047   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78048
78049   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78050   {
78051     try {
78052       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
78053     } catch (std::out_of_range& e) {
78054       {
78055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78056       };
78057     } catch (std::exception& e) {
78058       {
78059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78060       };
78061     } catch (...) {
78062       {
78063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78064       };
78065     }
78066   }
78067   jresult = (void *)result;
78068   return jresult;
78069 }
78070
78071
78072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
78073   void * jresult ;
78074   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78075
78076   {
78077     try {
78078       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
78079     } catch (std::out_of_range& e) {
78080       {
78081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78082       };
78083     } catch (std::exception& e) {
78084       {
78085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78086       };
78087     } catch (...) {
78088       {
78089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78090       };
78091     }
78092   }
78093   jresult = (void *)result;
78094   return jresult;
78095 }
78096
78097
78098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
78099   void * jresult ;
78100   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
78101   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78102
78103   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78104   if (!arg1) {
78105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78106     return 0;
78107   }
78108   {
78109     try {
78110       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
78111     } catch (std::out_of_range& e) {
78112       {
78113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78114       };
78115     } catch (std::exception& e) {
78116       {
78117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78118       };
78119     } catch (...) {
78120       {
78121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78122       };
78123     }
78124   }
78125   jresult = (void *)result;
78126   return jresult;
78127 }
78128
78129
78130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
78131   void * jresult ;
78132   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78133   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
78134   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78135
78136   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78137   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
78138   if (!arg2) {
78139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78140     return 0;
78141   }
78142   {
78143     try {
78144       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
78145     } catch (std::out_of_range& e) {
78146       {
78147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78148       };
78149     } catch (std::exception& e) {
78150       {
78151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78152       };
78153     } catch (...) {
78154       {
78155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78156       };
78157     }
78158   }
78159   jresult = (void *)result;
78160   return jresult;
78161 }
78162
78163
78164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
78165   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78166
78167   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78168   {
78169     try {
78170       delete arg1;
78171     } catch (std::out_of_range& e) {
78172       {
78173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78174       };
78175     } catch (std::exception& e) {
78176       {
78177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78178       };
78179     } catch (...) {
78180       {
78181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78182       };
78183     }
78184   }
78185 }
78186
78187
78188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
78189   void * jresult ;
78190   Dali::Toolkit::PageFactory *arg1 = 0 ;
78191   Dali::Vector2 *arg2 = 0 ;
78192   Dali::Toolkit::PageTurnLandscapeView result;
78193
78194   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78195   if (!arg1) {
78196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78197     return 0;
78198   }
78199   arg2 = (Dali::Vector2 *)jarg2;
78200   if (!arg2) {
78201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78202     return 0;
78203   }
78204   {
78205     try {
78206       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
78207     } catch (std::out_of_range& e) {
78208       {
78209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78210       };
78211     } catch (std::exception& e) {
78212       {
78213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78214       };
78215     } catch (...) {
78216       {
78217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78218       };
78219     }
78220   }
78221   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78222   return jresult;
78223 }
78224
78225
78226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
78227   void * jresult ;
78228   Dali::BaseHandle arg1 ;
78229   Dali::BaseHandle *argp1 ;
78230   Dali::Toolkit::PageTurnLandscapeView result;
78231
78232   argp1 = (Dali::BaseHandle *)jarg1;
78233   if (!argp1) {
78234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78235     return 0;
78236   }
78237   arg1 = *argp1;
78238   {
78239     try {
78240       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
78241     } catch (std::out_of_range& e) {
78242       {
78243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78244       };
78245     } catch (std::exception& e) {
78246       {
78247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78248       };
78249     } catch (...) {
78250       {
78251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78252       };
78253     }
78254   }
78255   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78256   return jresult;
78257 }
78258
78259
78260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
78261   void * jresult ;
78262   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78263
78264   {
78265     try {
78266       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
78267     } catch (std::out_of_range& e) {
78268       {
78269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78270       };
78271     } catch (std::exception& e) {
78272       {
78273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78274       };
78275     } catch (...) {
78276       {
78277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78278       };
78279     }
78280   }
78281   jresult = (void *)result;
78282   return jresult;
78283 }
78284
78285
78286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
78287   void * jresult ;
78288   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
78289   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78290
78291   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78292   if (!arg1) {
78293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78294     return 0;
78295   }
78296   {
78297     try {
78298       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
78299     } catch (std::out_of_range& e) {
78300       {
78301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78302       };
78303     } catch (std::exception& e) {
78304       {
78305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78306       };
78307     } catch (...) {
78308       {
78309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78310       };
78311     }
78312   }
78313   jresult = (void *)result;
78314   return jresult;
78315 }
78316
78317
78318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
78319   void * jresult ;
78320   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78321   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
78322   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78323
78324   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78325   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
78326   if (!arg2) {
78327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78328     return 0;
78329   }
78330   {
78331     try {
78332       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
78333     } catch (std::out_of_range& e) {
78334       {
78335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78336       };
78337     } catch (std::exception& e) {
78338       {
78339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78340       };
78341     } catch (...) {
78342       {
78343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78344       };
78345     }
78346   }
78347   jresult = (void *)result;
78348   return jresult;
78349 }
78350
78351
78352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
78353   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78354
78355   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78356   {
78357     try {
78358       delete arg1;
78359     } catch (std::out_of_range& e) {
78360       {
78361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78362       };
78363     } catch (std::exception& e) {
78364       {
78365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78366       };
78367     } catch (...) {
78368       {
78369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78370       };
78371     }
78372   }
78373 }
78374
78375
78376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
78377   void * jresult ;
78378   Dali::Toolkit::PageFactory *arg1 = 0 ;
78379   Dali::Vector2 *arg2 = 0 ;
78380   Dali::Toolkit::PageTurnPortraitView result;
78381
78382   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78383   if (!arg1) {
78384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78385     return 0;
78386   }
78387   arg2 = (Dali::Vector2 *)jarg2;
78388   if (!arg2) {
78389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78390     return 0;
78391   }
78392   {
78393     try {
78394       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
78395     } catch (std::out_of_range& e) {
78396       {
78397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78398       };
78399     } catch (std::exception& e) {
78400       {
78401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78402       };
78403     } catch (...) {
78404       {
78405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78406       };
78407     }
78408   }
78409   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78410   return jresult;
78411 }
78412
78413
78414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
78415   void * jresult ;
78416   Dali::BaseHandle arg1 ;
78417   Dali::BaseHandle *argp1 ;
78418   Dali::Toolkit::PageTurnPortraitView result;
78419
78420   argp1 = (Dali::BaseHandle *)jarg1;
78421   if (!argp1) {
78422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78423     return 0;
78424   }
78425   arg1 = *argp1;
78426   {
78427     try {
78428       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
78429     } catch (std::out_of_range& e) {
78430       {
78431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78432       };
78433     } catch (std::exception& e) {
78434       {
78435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78436       };
78437     } catch (...) {
78438       {
78439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78440       };
78441     }
78442   }
78443   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78444   return jresult;
78445 }
78446
78447
78448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
78449   int jresult ;
78450   int result;
78451
78452   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
78453   jresult = (int)result;
78454   return jresult;
78455 }
78456
78457
78458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
78459   int jresult ;
78460   int result;
78461
78462   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
78463   jresult = (int)result;
78464   return jresult;
78465 }
78466
78467
78468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
78469   int jresult ;
78470   int result;
78471
78472   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
78473   jresult = (int)result;
78474   return jresult;
78475 }
78476
78477
78478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
78479   void * jresult ;
78480   Dali::Toolkit::ToggleButton::Property *result = 0 ;
78481
78482   {
78483     try {
78484       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
78485     } catch (std::out_of_range& e) {
78486       {
78487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78488       };
78489     } catch (std::exception& e) {
78490       {
78491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78492       };
78493     } catch (...) {
78494       {
78495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78496       };
78497     }
78498   }
78499   jresult = (void *)result;
78500   return jresult;
78501 }
78502
78503
78504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
78505   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
78506
78507   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
78508   {
78509     try {
78510       delete arg1;
78511     } catch (std::out_of_range& e) {
78512       {
78513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78514       };
78515     } catch (std::exception& e) {
78516       {
78517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78518       };
78519     } catch (...) {
78520       {
78521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78522       };
78523     }
78524   }
78525 }
78526
78527
78528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
78529   void * jresult ;
78530   Dali::Toolkit::ToggleButton *result = 0 ;
78531
78532   {
78533     try {
78534       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
78535     } catch (std::out_of_range& e) {
78536       {
78537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78538       };
78539     } catch (std::exception& e) {
78540       {
78541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78542       };
78543     } catch (...) {
78544       {
78545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78546       };
78547     }
78548   }
78549   jresult = (void *)result;
78550   return jresult;
78551 }
78552
78553
78554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
78555   void * jresult ;
78556   Dali::Toolkit::ToggleButton *arg1 = 0 ;
78557   Dali::Toolkit::ToggleButton *result = 0 ;
78558
78559   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78560   if (!arg1) {
78561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78562     return 0;
78563   }
78564   {
78565     try {
78566       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
78567     } catch (std::out_of_range& e) {
78568       {
78569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78570       };
78571     } catch (std::exception& e) {
78572       {
78573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78574       };
78575     } catch (...) {
78576       {
78577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78578       };
78579     }
78580   }
78581   jresult = (void *)result;
78582   return jresult;
78583 }
78584
78585
78586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
78587   void * jresult ;
78588   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78589   Dali::Toolkit::ToggleButton *arg2 = 0 ;
78590   Dali::Toolkit::ToggleButton *result = 0 ;
78591
78592   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78593   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
78594   if (!arg2) {
78595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78596     return 0;
78597   }
78598   {
78599     try {
78600       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
78601     } catch (std::out_of_range& e) {
78602       {
78603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78604       };
78605     } catch (std::exception& e) {
78606       {
78607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78608       };
78609     } catch (...) {
78610       {
78611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78612       };
78613     }
78614   }
78615   jresult = (void *)result;
78616   return jresult;
78617 }
78618
78619
78620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
78621   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78622
78623   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78624   {
78625     try {
78626       delete arg1;
78627     } catch (std::out_of_range& e) {
78628       {
78629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78630       };
78631     } catch (std::exception& e) {
78632       {
78633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78634       };
78635     } catch (...) {
78636       {
78637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78638       };
78639     }
78640   }
78641 }
78642
78643
78644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
78645   void * jresult ;
78646   Dali::Toolkit::ToggleButton result;
78647
78648   {
78649     try {
78650       result = Dali::Toolkit::ToggleButton::New();
78651     } catch (std::out_of_range& e) {
78652       {
78653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78654       };
78655     } catch (std::exception& e) {
78656       {
78657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78658       };
78659     } catch (...) {
78660       {
78661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78662       };
78663     }
78664   }
78665   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78666   return jresult;
78667 }
78668
78669
78670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
78671   void * jresult ;
78672   Dali::BaseHandle arg1 ;
78673   Dali::BaseHandle *argp1 ;
78674   Dali::Toolkit::ToggleButton result;
78675
78676   argp1 = (Dali::BaseHandle *)jarg1;
78677   if (!argp1) {
78678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78679     return 0;
78680   }
78681   arg1 = *argp1;
78682   {
78683     try {
78684       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
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::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78700   return jresult;
78701 }
78702
78703
78704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
78705   void * jresult ;
78706   Dali::Toolkit::Visual::Base *result = 0 ;
78707
78708   {
78709     try {
78710       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
78711     } catch (std::out_of_range& e) {
78712       {
78713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78714       };
78715     } catch (std::exception& e) {
78716       {
78717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78718       };
78719     } catch (...) {
78720       {
78721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78722       };
78723     }
78724   }
78725   jresult = (void *)result;
78726   return jresult;
78727 }
78728
78729
78730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
78731   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78732
78733   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78734   {
78735     try {
78736       delete arg1;
78737     } catch (std::out_of_range& e) {
78738       {
78739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78740       };
78741     } catch (std::exception& e) {
78742       {
78743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78744       };
78745     } catch (...) {
78746       {
78747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78748       };
78749     }
78750   }
78751 }
78752
78753
78754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
78755   void * jresult ;
78756   Dali::Toolkit::Visual::Base *arg1 = 0 ;
78757   Dali::Toolkit::Visual::Base *result = 0 ;
78758
78759   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78760   if (!arg1) {
78761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78762     return 0;
78763   }
78764   {
78765     try {
78766       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
78767     } catch (std::out_of_range& e) {
78768       {
78769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78770       };
78771     } catch (std::exception& e) {
78772       {
78773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78774       };
78775     } catch (...) {
78776       {
78777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78778       };
78779     }
78780   }
78781   jresult = (void *)result;
78782   return jresult;
78783 }
78784
78785
78786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
78787   void * jresult ;
78788   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78789   Dali::Toolkit::Visual::Base *arg2 = 0 ;
78790   Dali::Toolkit::Visual::Base *result = 0 ;
78791
78792   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78793   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
78794   if (!arg2) {
78795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78796     return 0;
78797   }
78798   {
78799     try {
78800       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
78801     } catch (std::out_of_range& e) {
78802       {
78803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78804       };
78805     } catch (std::exception& e) {
78806       {
78807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78808       };
78809     } catch (...) {
78810       {
78811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78812       };
78813     }
78814   }
78815   jresult = (void *)result;
78816   return jresult;
78817 }
78818
78819
78820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
78821   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78822   std::string *arg2 = 0 ;
78823
78824   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78825   if (!jarg2) {
78826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78827     return ;
78828   }
78829   std::string arg2_str(jarg2);
78830   arg2 = &arg2_str;
78831   {
78832     try {
78833       (arg1)->SetName((std::string const &)*arg2);
78834     } catch (std::out_of_range& e) {
78835       {
78836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78837       };
78838     } catch (std::exception& e) {
78839       {
78840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78841       };
78842     } catch (...) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78845       };
78846     }
78847   }
78848
78849   //argout typemap for const std::string&
78850
78851 }
78852
78853
78854 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
78855   char * jresult ;
78856   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78857   std::string *result = 0 ;
78858
78859   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78860   {
78861     try {
78862       result = (std::string *) &(arg1)->GetName();
78863     } catch (std::out_of_range& e) {
78864       {
78865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78866       };
78867     } catch (std::exception& e) {
78868       {
78869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78870       };
78871     } catch (...) {
78872       {
78873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78874       };
78875     }
78876   }
78877   jresult = SWIG_csharp_string_callback(result->c_str());
78878   return jresult;
78879 }
78880
78881
78882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
78883   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78884   Dali::Property::Map *arg2 = 0 ;
78885   Dali::Size arg3 ;
78886   Dali::Size *argp3 ;
78887
78888   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78889   arg2 = (Dali::Property::Map *)jarg2;
78890   if (!arg2) {
78891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
78892     return ;
78893   }
78894   argp3 = (Dali::Size *)jarg3;
78895   if (!argp3) {
78896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78897     return ;
78898   }
78899   arg3 = *argp3;
78900   {
78901     try {
78902       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
78903     } catch (std::out_of_range& e) {
78904       {
78905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78906       };
78907     } catch (std::exception& e) {
78908       {
78909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78910       };
78911     } catch (...) {
78912       {
78913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78914       };
78915     }
78916   }
78917 }
78918
78919
78920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
78921   float jresult ;
78922   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78923   float arg2 ;
78924   float result;
78925
78926   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78927   arg2 = (float)jarg2;
78928   {
78929     try {
78930       result = (float)(arg1)->GetHeightForWidth(arg2);
78931     } catch (std::out_of_range& e) {
78932       {
78933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78934       };
78935     } catch (std::exception& e) {
78936       {
78937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78938       };
78939     } catch (...) {
78940       {
78941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78942       };
78943     }
78944   }
78945   jresult = result;
78946   return jresult;
78947 }
78948
78949
78950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
78951   float jresult ;
78952   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78953   float arg2 ;
78954   float result;
78955
78956   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78957   arg2 = (float)jarg2;
78958   {
78959     try {
78960       result = (float)(arg1)->GetWidthForHeight(arg2);
78961     } catch (std::out_of_range& e) {
78962       {
78963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78964       };
78965     } catch (std::exception& e) {
78966       {
78967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78968       };
78969     } catch (...) {
78970       {
78971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78972       };
78973     }
78974   }
78975   jresult = result;
78976   return jresult;
78977 }
78978
78979
78980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
78981   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78982   Dali::Vector2 *arg2 = 0 ;
78983
78984   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78985   arg2 = (Dali::Vector2 *)jarg2;
78986   if (!arg2) {
78987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
78988     return ;
78989   }
78990   {
78991     try {
78992       (arg1)->GetNaturalSize(*arg2);
78993     } catch (std::out_of_range& e) {
78994       {
78995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78996       };
78997     } catch (std::exception& e) {
78998       {
78999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79000       };
79001     } catch (...) {
79002       {
79003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79004       };
79005     }
79006   }
79007 }
79008
79009
79010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
79011   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79012   float arg2 ;
79013
79014   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79015   arg2 = (int)jarg2;
79016   {
79017     try {
79018       (arg1)->SetDepthIndex(arg2);
79019     } catch (std::out_of_range& e) {
79020       {
79021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79022       };
79023     } catch (std::exception& e) {
79024       {
79025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79026       };
79027     } catch (...) {
79028       {
79029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79030       };
79031     }
79032   }
79033 }
79034
79035
79036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
79037   int jresult ;
79038   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79039   int result;
79040
79041   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79042   {
79043     try {
79044       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
79045     } catch (std::out_of_range& e) {
79046       {
79047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79048       };
79049     } catch (std::exception& e) {
79050       {
79051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79052       };
79053     } catch (...) {
79054       {
79055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79056       };
79057     }
79058   }
79059   jresult = result;
79060   return jresult;
79061 }
79062
79063
79064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
79065   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79066   Dali::Property::Map *arg2 = 0 ;
79067
79068   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79069   arg2 = (Dali::Property::Map *)jarg2;
79070   if (!arg2) {
79071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
79072     return ;
79073   }
79074   {
79075     try {
79076       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
79077     } catch (std::out_of_range& e) {
79078       {
79079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79080       };
79081     } catch (std::exception& e) {
79082       {
79083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79084       };
79085     } catch (...) {
79086       {
79087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79088       };
79089     }
79090   }
79091 }
79092
79093
79094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
79095   void * jresult ;
79096   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
79097   Dali::Toolkit::Visual::Base *result = 0 ;
79098
79099   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
79100   {
79101     try {
79102       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
79103     } catch (std::out_of_range& e) {
79104       {
79105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79106       };
79107     } catch (std::exception& e) {
79108       {
79109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79110       };
79111     } catch (...) {
79112       {
79113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79114       };
79115     }
79116   }
79117   jresult = (void *)result;
79118   return jresult;
79119 }
79120
79121
79122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
79123   void * jresult ;
79124   Dali::Toolkit::VisualFactory result;
79125
79126   {
79127     try {
79128       result = Dali::Toolkit::VisualFactory::Get();
79129     } catch (std::out_of_range& e) {
79130       {
79131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79132       };
79133     } catch (std::exception& e) {
79134       {
79135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79136       };
79137     } catch (...) {
79138       {
79139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79140       };
79141     }
79142   }
79143   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
79144   return jresult;
79145 }
79146
79147
79148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
79149   void * jresult ;
79150   Dali::Toolkit::VisualFactory *result = 0 ;
79151
79152   {
79153     try {
79154       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
79155     } catch (std::out_of_range& e) {
79156       {
79157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79158       };
79159     } catch (std::exception& e) {
79160       {
79161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79162       };
79163     } catch (...) {
79164       {
79165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79166       };
79167     }
79168   }
79169   jresult = (void *)result;
79170   return jresult;
79171 }
79172
79173
79174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
79175   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79176
79177   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79178   {
79179     try {
79180       delete arg1;
79181     } catch (std::out_of_range& e) {
79182       {
79183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79184       };
79185     } catch (std::exception& e) {
79186       {
79187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79188       };
79189     } catch (...) {
79190       {
79191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79192       };
79193     }
79194   }
79195 }
79196
79197
79198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
79199   void * jresult ;
79200   Dali::Toolkit::VisualFactory *arg1 = 0 ;
79201   Dali::Toolkit::VisualFactory *result = 0 ;
79202
79203   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79204   if (!arg1) {
79205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79206     return 0;
79207   }
79208   {
79209     try {
79210       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
79211     } catch (std::out_of_range& e) {
79212       {
79213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79214       };
79215     } catch (std::exception& e) {
79216       {
79217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79218       };
79219     } catch (...) {
79220       {
79221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79222       };
79223     }
79224   }
79225   jresult = (void *)result;
79226   return jresult;
79227 }
79228
79229
79230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
79231   void * jresult ;
79232   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79233   Dali::Toolkit::VisualFactory *arg2 = 0 ;
79234   Dali::Toolkit::VisualFactory *result = 0 ;
79235
79236   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79237   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
79238   if (!arg2) {
79239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79240     return 0;
79241   }
79242   {
79243     try {
79244       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
79245     } catch (std::out_of_range& e) {
79246       {
79247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79248       };
79249     } catch (std::exception& e) {
79250       {
79251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79252       };
79253     } catch (...) {
79254       {
79255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79256       };
79257     }
79258   }
79259   jresult = (void *)result;
79260   return jresult;
79261 }
79262
79263
79264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
79265   void * jresult ;
79266   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79267   Dali::Property::Map *arg2 = 0 ;
79268   Dali::Toolkit::Visual::Base result;
79269
79270   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79271   arg2 = (Dali::Property::Map *)jarg2;
79272   if (!arg2) {
79273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
79274     return 0;
79275   }
79276   {
79277     try {
79278       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
79279     } catch (std::out_of_range& e) {
79280       {
79281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79282       };
79283     } catch (std::exception& e) {
79284       {
79285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79286       };
79287     } catch (...) {
79288       {
79289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79290       };
79291     }
79292   }
79293   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79294   return jresult;
79295 }
79296
79297
79298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
79299   void * jresult ;
79300   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79301   Dali::Image *arg2 = 0 ;
79302   Dali::Toolkit::Visual::Base result;
79303
79304   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79305   arg2 = (Dali::Image *)jarg2;
79306   if (!arg2) {
79307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
79308     return 0;
79309   }
79310   {
79311     try {
79312       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
79313     } catch (std::out_of_range& e) {
79314       {
79315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79316       };
79317     } catch (std::exception& e) {
79318       {
79319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79320       };
79321     } catch (...) {
79322       {
79323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79324       };
79325     }
79326   }
79327   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79328   return jresult;
79329 }
79330
79331
79332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
79333   void * jresult ;
79334   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79335   std::string *arg2 = 0 ;
79336   Dali::ImageDimensions arg3 ;
79337   Dali::ImageDimensions *argp3 ;
79338   Dali::Toolkit::Visual::Base result;
79339
79340   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79341   if (!jarg2) {
79342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79343     return 0;
79344   }
79345   std::string arg2_str(jarg2);
79346   arg2 = &arg2_str;
79347   argp3 = (Dali::ImageDimensions *)jarg3;
79348   if (!argp3) {
79349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79350     return 0;
79351   }
79352   arg3 = *argp3;
79353   {
79354     try {
79355       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
79356     } catch (std::out_of_range& e) {
79357       {
79358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79359       };
79360     } catch (std::exception& e) {
79361       {
79362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79363       };
79364     } catch (...) {
79365       {
79366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79367       };
79368     }
79369   }
79370   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79371
79372   //argout typemap for const std::string&
79373
79374   return jresult;
79375 }
79376
79377
79378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
79379   void * jresult ;
79380   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79381
79382   {
79383     try {
79384       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
79385     } catch (std::out_of_range& e) {
79386       {
79387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79388       };
79389     } catch (std::exception& e) {
79390       {
79391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79392       };
79393     } catch (...) {
79394       {
79395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79396       };
79397     }
79398   }
79399   jresult = (void *)result;
79400   return jresult;
79401 }
79402
79403
79404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
79405   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79406
79407   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79408   {
79409     try {
79410       delete arg1;
79411     } catch (std::out_of_range& e) {
79412       {
79413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79414       };
79415     } catch (std::exception& e) {
79416       {
79417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79418       };
79419     } catch (...) {
79420       {
79421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79422       };
79423     }
79424   }
79425 }
79426
79427
79428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
79429   void * jresult ;
79430   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
79431   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79432
79433   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79434   if (!arg1) {
79435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79436     return 0;
79437   }
79438   {
79439     try {
79440       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
79441     } catch (std::out_of_range& e) {
79442       {
79443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79444       };
79445     } catch (std::exception& e) {
79446       {
79447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79448       };
79449     } catch (...) {
79450       {
79451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79452       };
79453     }
79454   }
79455   jresult = (void *)result;
79456   return jresult;
79457 }
79458
79459
79460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
79461   void * jresult ;
79462   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79463   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
79464   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79465
79466   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79467   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
79468   if (!arg2) {
79469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79470     return 0;
79471   }
79472   {
79473     try {
79474       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
79475     } catch (std::out_of_range& e) {
79476       {
79477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79478       };
79479     } catch (std::exception& e) {
79480       {
79481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79482       };
79483     } catch (...) {
79484       {
79485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79486       };
79487     }
79488   }
79489   jresult = (void *)result;
79490   return jresult;
79491 }
79492
79493
79494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
79495   void * jresult ;
79496   Dali::Toolkit::AsyncImageLoader result;
79497
79498   {
79499     try {
79500       result = Dali::Toolkit::AsyncImageLoader::New();
79501     } catch (std::out_of_range& e) {
79502       {
79503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79504       };
79505     } catch (std::exception& e) {
79506       {
79507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79508       };
79509     } catch (...) {
79510       {
79511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79512       };
79513     }
79514   }
79515   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79516   return jresult;
79517 }
79518
79519
79520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
79521   void * jresult ;
79522   Dali::BaseHandle arg1 ;
79523   Dali::BaseHandle *argp1 ;
79524   Dali::Toolkit::AsyncImageLoader result;
79525
79526   argp1 = (Dali::BaseHandle *)jarg1;
79527   if (!argp1) {
79528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79529     return 0;
79530   }
79531   arg1 = *argp1;
79532   {
79533     try {
79534       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
79535     } catch (std::out_of_range& e) {
79536       {
79537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79538       };
79539     } catch (std::exception& e) {
79540       {
79541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79542       };
79543     } catch (...) {
79544       {
79545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79546       };
79547     }
79548   }
79549   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79550   return jresult;
79551 }
79552
79553
79554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
79555   unsigned int jresult ;
79556   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79557   std::string *arg2 = 0 ;
79558   uint32_t result;
79559
79560   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79561   if (!jarg2) {
79562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79563     return 0;
79564   }
79565   std::string arg2_str(jarg2);
79566   arg2 = &arg2_str;
79567   {
79568     try {
79569       result = (arg1)->Load((std::string const &)*arg2);
79570     } catch (std::out_of_range& e) {
79571       {
79572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79573       };
79574     } catch (std::exception& e) {
79575       {
79576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79577       };
79578     } catch (...) {
79579       {
79580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79581       };
79582     }
79583   }
79584   jresult = result;
79585
79586   //argout typemap for const std::string&
79587
79588   return jresult;
79589 }
79590
79591
79592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
79593   unsigned int jresult ;
79594   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79595   std::string *arg2 = 0 ;
79596   Dali::ImageDimensions arg3 ;
79597   Dali::ImageDimensions *argp3 ;
79598   uint32_t result;
79599
79600   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79601   if (!jarg2) {
79602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79603     return 0;
79604   }
79605   std::string arg2_str(jarg2);
79606   arg2 = &arg2_str;
79607   argp3 = (Dali::ImageDimensions *)jarg3;
79608   if (!argp3) {
79609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79610     return 0;
79611   }
79612   arg3 = *argp3;
79613   {
79614     try {
79615       result = (arg1)->Load((std::string const &)*arg2,arg3);
79616     } catch (std::out_of_range& e) {
79617       {
79618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79619       };
79620     } catch (std::exception& e) {
79621       {
79622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79623       };
79624     } catch (...) {
79625       {
79626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79627       };
79628     }
79629   }
79630   jresult = result;
79631
79632   //argout typemap for const std::string&
79633
79634   return jresult;
79635 }
79636
79637
79638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
79639   unsigned int jresult ;
79640   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79641   std::string *arg2 = 0 ;
79642   Dali::ImageDimensions arg3 ;
79643   Dali::FittingMode::Type arg4 ;
79644   Dali::SamplingMode::Type arg5 ;
79645   bool arg6 ;
79646   Dali::ImageDimensions *argp3 ;
79647   uint32_t result;
79648
79649   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79650   if (!jarg2) {
79651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79652     return 0;
79653   }
79654   std::string arg2_str(jarg2);
79655   arg2 = &arg2_str;
79656   argp3 = (Dali::ImageDimensions *)jarg3;
79657   if (!argp3) {
79658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79659     return 0;
79660   }
79661   arg3 = *argp3;
79662   arg4 = (Dali::FittingMode::Type)jarg4;
79663   arg5 = (Dali::SamplingMode::Type)jarg5;
79664   arg6 = jarg6 ? true : false;
79665   {
79666     try {
79667       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
79668     } catch (std::out_of_range& e) {
79669       {
79670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79671       };
79672     } catch (std::exception& e) {
79673       {
79674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79675       };
79676     } catch (...) {
79677       {
79678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79679       };
79680     }
79681   }
79682   jresult = result;
79683
79684   //argout typemap for const std::string&
79685
79686   return jresult;
79687 }
79688
79689
79690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
79691   unsigned int jresult ;
79692   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79693   uint32_t arg2 ;
79694   bool result;
79695
79696   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79697   arg2 = (uint32_t)jarg2;
79698   {
79699     try {
79700       result = (bool)(arg1)->Cancel(arg2);
79701     } catch (std::out_of_range& e) {
79702       {
79703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79704       };
79705     } catch (std::exception& e) {
79706       {
79707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79708       };
79709     } catch (...) {
79710       {
79711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79712       };
79713     }
79714   }
79715   jresult = result;
79716   return jresult;
79717 }
79718
79719
79720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
79721   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79722
79723   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79724   {
79725     try {
79726       (arg1)->CancelAll();
79727     } catch (std::out_of_range& e) {
79728       {
79729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79730       };
79731     } catch (std::exception& e) {
79732       {
79733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79734       };
79735     } catch (...) {
79736       {
79737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79738       };
79739     }
79740   }
79741 }
79742
79743
79744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
79745   void * jresult ;
79746   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79747   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
79748
79749   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79750   {
79751     try {
79752       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
79753     } catch (std::out_of_range& e) {
79754       {
79755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79756       };
79757     } catch (std::exception& e) {
79758       {
79759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79760       };
79761     } catch (...) {
79762       {
79763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79764       };
79765     }
79766   }
79767   jresult = (void *)result;
79768   return jresult;
79769 }
79770
79771
79772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
79773   void * jresult ;
79774   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
79775   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79776
79777   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
79778   {
79779     try {
79780       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
79781     } catch (std::out_of_range& e) {
79782       {
79783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79784       };
79785     } catch (std::exception& e) {
79786       {
79787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79788       };
79789     } catch (...) {
79790       {
79791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79792       };
79793     }
79794   }
79795   jresult = (void *)result;
79796   return jresult;
79797 }
79798
79799
79800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
79801   void * jresult ;
79802   std::string *arg1 = 0 ;
79803   Dali::PixelData result;
79804
79805   if (!jarg1) {
79806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79807     return 0;
79808   }
79809   std::string arg1_str(jarg1);
79810   arg1 = &arg1_str;
79811   {
79812     try {
79813       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
79814     } catch (std::out_of_range& e) {
79815       {
79816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79817       };
79818     } catch (std::exception& e) {
79819       {
79820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79821       };
79822     } catch (...) {
79823       {
79824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79825       };
79826     }
79827   }
79828   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79829
79830   //argout typemap for const std::string&
79831
79832   return jresult;
79833 }
79834
79835
79836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
79837   void * jresult ;
79838   std::string *arg1 = 0 ;
79839   Dali::ImageDimensions arg2 ;
79840   Dali::ImageDimensions *argp2 ;
79841   Dali::PixelData result;
79842
79843   if (!jarg1) {
79844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79845     return 0;
79846   }
79847   std::string arg1_str(jarg1);
79848   arg1 = &arg1_str;
79849   argp2 = (Dali::ImageDimensions *)jarg2;
79850   if (!argp2) {
79851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79852     return 0;
79853   }
79854   arg2 = *argp2;
79855   {
79856     try {
79857       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
79858     } catch (std::out_of_range& e) {
79859       {
79860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79861       };
79862     } catch (std::exception& e) {
79863       {
79864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79865       };
79866     } catch (...) {
79867       {
79868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79869       };
79870     }
79871   }
79872   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79873
79874   //argout typemap for const std::string&
79875
79876   return jresult;
79877 }
79878
79879
79880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
79881   void * jresult ;
79882   std::string *arg1 = 0 ;
79883   Dali::ImageDimensions arg2 ;
79884   Dali::FittingMode::Type arg3 ;
79885   Dali::SamplingMode::Type arg4 ;
79886   bool arg5 ;
79887   Dali::ImageDimensions *argp2 ;
79888   Dali::PixelData result;
79889
79890   if (!jarg1) {
79891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79892     return 0;
79893   }
79894   std::string arg1_str(jarg1);
79895   arg1 = &arg1_str;
79896   argp2 = (Dali::ImageDimensions *)jarg2;
79897   if (!argp2) {
79898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79899     return 0;
79900   }
79901   arg2 = *argp2;
79902   arg3 = (Dali::FittingMode::Type)jarg3;
79903   arg4 = (Dali::SamplingMode::Type)jarg4;
79904   arg5 = jarg5 ? true : false;
79905   {
79906     try {
79907       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
79908     } catch (std::out_of_range& e) {
79909       {
79910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79911       };
79912     } catch (std::exception& e) {
79913       {
79914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79915       };
79916     } catch (...) {
79917       {
79918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79919       };
79920     }
79921   }
79922   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79923
79924   //argout typemap for const std::string&
79925
79926   return jresult;
79927 }
79928
79929
79930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
79931   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79932
79933   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79934   {
79935     try {
79936       delete arg1;
79937     } catch (std::out_of_range& e) {
79938       {
79939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79940       };
79941     } catch (std::exception& e) {
79942       {
79943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79944       };
79945     } catch (...) {
79946       {
79947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79948       };
79949     }
79950   }
79951 }
79952
79953
79954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
79955   void * jresult ;
79956   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
79957   Dali::Actor arg2 ;
79958   Dali::Actor arg3 ;
79959   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
79960   Dali::Actor *argp2 ;
79961   Dali::Actor *argp3 ;
79962   Dali::Actor result;
79963
79964   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
79965   argp2 = (Dali::Actor *)jarg2;
79966   if (!argp2) {
79967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79968     return 0;
79969   }
79970   arg2 = *argp2;
79971   argp3 = (Dali::Actor *)jarg3;
79972   if (!argp3) {
79973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79974     return 0;
79975   }
79976   arg3 = *argp3;
79977   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
79978   {
79979     try {
79980       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
79981     } catch (std::out_of_range& e) {
79982       {
79983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79984       };
79985     } catch (std::exception& e) {
79986       {
79987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79988       };
79989     } catch (...) {
79990       {
79991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79992       };
79993     }
79994   }
79995   jresult = new Dali::Actor((const Dali::Actor &)result);
79996   return jresult;
79997 }
79998
79999
80000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
80001   void * jresult ;
80002   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
80003
80004   {
80005     try {
80006       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
80007     } catch (std::out_of_range& e) {
80008       {
80009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80010       };
80011     } catch (std::exception& e) {
80012       {
80013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80014       };
80015     } catch (...) {
80016       {
80017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80018       };
80019     }
80020   }
80021   jresult = (void *)result;
80022   return jresult;
80023 }
80024
80025
80026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
80027   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
80028   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
80029   if (director) {
80030     director->swig_connect_director(callback0);
80031   }
80032 }
80033
80034
80035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
80036   KeyboardFocusManager arg1 ;
80037   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
80038   KeyboardFocusManager *argp1 ;
80039
80040   argp1 = (KeyboardFocusManager *)jarg1;
80041   if (!argp1) {
80042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
80043     return ;
80044   }
80045   arg1 = *argp1;
80046   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
80047   if (!arg2) {
80048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
80049     return ;
80050   }
80051   {
80052     try {
80053       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
80054     } catch (std::out_of_range& e) {
80055       {
80056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80057       };
80058     } catch (std::exception& e) {
80059       {
80060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80061       };
80062     } catch (...) {
80063       {
80064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80065       };
80066     }
80067   }
80068 }
80069
80070
80071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
80072   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80073
80074   arg1 = (std::vector< unsigned int > *)jarg1;
80075   {
80076     try {
80077       (arg1)->clear();
80078     } catch (std::out_of_range& e) {
80079       {
80080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80081       };
80082     } catch (std::exception& e) {
80083       {
80084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80085       };
80086     } catch (...) {
80087       {
80088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80089       };
80090     }
80091   }
80092 }
80093
80094
80095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
80096   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80097   unsigned int *arg2 = 0 ;
80098   unsigned int temp2 ;
80099
80100   arg1 = (std::vector< unsigned int > *)jarg1;
80101   temp2 = (unsigned int)jarg2;
80102   arg2 = &temp2;
80103   {
80104     try {
80105       (arg1)->push_back((unsigned int const &)*arg2);
80106     } catch (std::out_of_range& e) {
80107       {
80108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80109       };
80110     } catch (std::exception& e) {
80111       {
80112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80113       };
80114     } catch (...) {
80115       {
80116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80117       };
80118     }
80119   }
80120 }
80121
80122
80123 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
80124   unsigned long jresult ;
80125   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80126   std::vector< unsigned int >::size_type result;
80127
80128   arg1 = (std::vector< unsigned int > *)jarg1;
80129   {
80130     try {
80131       result = ((std::vector< unsigned int > const *)arg1)->size();
80132     } catch (std::out_of_range& e) {
80133       {
80134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80135       };
80136     } catch (std::exception& e) {
80137       {
80138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80139       };
80140     } catch (...) {
80141       {
80142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80143       };
80144     }
80145   }
80146   jresult = (unsigned long)result;
80147   return jresult;
80148 }
80149
80150
80151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
80152   unsigned long jresult ;
80153   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80154   std::vector< unsigned int >::size_type result;
80155
80156   arg1 = (std::vector< unsigned int > *)jarg1;
80157   {
80158     try {
80159       result = ((std::vector< unsigned int > const *)arg1)->capacity();
80160     } catch (std::out_of_range& e) {
80161       {
80162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80163       };
80164     } catch (std::exception& e) {
80165       {
80166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80167       };
80168     } catch (...) {
80169       {
80170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80171       };
80172     }
80173   }
80174   jresult = (unsigned long)result;
80175   return jresult;
80176 }
80177
80178
80179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
80180   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80181   std::vector< unsigned int >::size_type arg2 ;
80182
80183   arg1 = (std::vector< unsigned int > *)jarg1;
80184   arg2 = (std::vector< unsigned int >::size_type)jarg2;
80185   {
80186     try {
80187       (arg1)->reserve(arg2);
80188     } catch (std::out_of_range& e) {
80189       {
80190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80191       };
80192     } catch (std::exception& e) {
80193       {
80194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80195       };
80196     } catch (...) {
80197       {
80198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80199       };
80200     }
80201   }
80202 }
80203
80204
80205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
80206   void * jresult ;
80207   std::vector< unsigned int > *result = 0 ;
80208
80209   {
80210     try {
80211       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
80212     } catch (std::out_of_range& e) {
80213       {
80214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80215       };
80216     } catch (std::exception& e) {
80217       {
80218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80219       };
80220     } catch (...) {
80221       {
80222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80223       };
80224     }
80225   }
80226   jresult = (void *)result;
80227   return jresult;
80228 }
80229
80230
80231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
80232   void * jresult ;
80233   std::vector< unsigned int > *arg1 = 0 ;
80234   std::vector< unsigned int > *result = 0 ;
80235
80236   arg1 = (std::vector< unsigned int > *)jarg1;
80237   if (!arg1) {
80238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80239     return 0;
80240   }
80241   {
80242     try {
80243       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
80244     } catch (std::out_of_range& e) {
80245       {
80246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80247       };
80248     } catch (std::exception& e) {
80249       {
80250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80251       };
80252     } catch (...) {
80253       {
80254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80255       };
80256     }
80257   }
80258   jresult = (void *)result;
80259   return jresult;
80260 }
80261
80262
80263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
80264   void * jresult ;
80265   int arg1 ;
80266   std::vector< unsigned int > *result = 0 ;
80267
80268   arg1 = (int)jarg1;
80269   {
80270     try {
80271       try {
80272         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
80273       }
80274       catch(std::out_of_range &_e) {
80275         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80276         return 0;
80277       }
80278
80279     } catch (std::out_of_range& e) {
80280       {
80281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80282       };
80283     } catch (std::exception& e) {
80284       {
80285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80286       };
80287     } catch (...) {
80288       {
80289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80290       };
80291     }
80292   }
80293   jresult = (void *)result;
80294   return jresult;
80295 }
80296
80297
80298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
80299   unsigned int jresult ;
80300   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80301   int arg2 ;
80302   unsigned int result;
80303
80304   arg1 = (std::vector< unsigned int > *)jarg1;
80305   arg2 = (int)jarg2;
80306   {
80307     try {
80308       try {
80309         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
80310       }
80311       catch(std::out_of_range &_e) {
80312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80313         return 0;
80314       }
80315
80316     } catch (std::out_of_range& e) {
80317       {
80318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80319       };
80320     } catch (std::exception& e) {
80321       {
80322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80323       };
80324     } catch (...) {
80325       {
80326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80327       };
80328     }
80329   }
80330   jresult = result;
80331   return jresult;
80332 }
80333
80334
80335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
80336   unsigned int jresult ;
80337   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80338   int arg2 ;
80339   unsigned int *result = 0 ;
80340
80341   arg1 = (std::vector< unsigned int > *)jarg1;
80342   arg2 = (int)jarg2;
80343   {
80344     try {
80345       try {
80346         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
80347       }
80348       catch(std::out_of_range &_e) {
80349         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80350         return 0;
80351       }
80352
80353     } catch (std::out_of_range& e) {
80354       {
80355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80356       };
80357     } catch (std::exception& e) {
80358       {
80359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80360       };
80361     } catch (...) {
80362       {
80363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80364       };
80365     }
80366   }
80367   jresult = *result;
80368   return jresult;
80369 }
80370
80371
80372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
80373   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80374   int arg2 ;
80375   unsigned int *arg3 = 0 ;
80376   unsigned int temp3 ;
80377
80378   arg1 = (std::vector< unsigned int > *)jarg1;
80379   arg2 = (int)jarg2;
80380   temp3 = (unsigned int)jarg3;
80381   arg3 = &temp3;
80382   {
80383     try {
80384       try {
80385         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
80386       }
80387       catch(std::out_of_range &_e) {
80388         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80389         return ;
80390       }
80391
80392     } catch (std::out_of_range& e) {
80393       {
80394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80395       };
80396     } catch (std::exception& e) {
80397       {
80398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80399       };
80400     } catch (...) {
80401       {
80402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80403       };
80404     }
80405   }
80406 }
80407
80408
80409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
80410   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80411   std::vector< unsigned int > *arg2 = 0 ;
80412
80413   arg1 = (std::vector< unsigned int > *)jarg1;
80414   arg2 = (std::vector< unsigned int > *)jarg2;
80415   if (!arg2) {
80416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80417     return ;
80418   }
80419   {
80420     try {
80421       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
80422     } catch (std::out_of_range& e) {
80423       {
80424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80425       };
80426     } catch (std::exception& e) {
80427       {
80428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80429       };
80430     } catch (...) {
80431       {
80432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80433       };
80434     }
80435   }
80436 }
80437
80438
80439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
80440   void * jresult ;
80441   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80442   int arg2 ;
80443   int arg3 ;
80444   std::vector< unsigned int > *result = 0 ;
80445
80446   arg1 = (std::vector< unsigned int > *)jarg1;
80447   arg2 = (int)jarg2;
80448   arg3 = (int)jarg3;
80449   {
80450     try {
80451       try {
80452         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
80453       }
80454       catch(std::out_of_range &_e) {
80455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80456         return 0;
80457       }
80458       catch(std::invalid_argument &_e) {
80459         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80460         return 0;
80461       }
80462
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 = (void *)result;
80478   return jresult;
80479 }
80480
80481
80482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
80483   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80484   int arg2 ;
80485   unsigned int *arg3 = 0 ;
80486   unsigned int temp3 ;
80487
80488   arg1 = (std::vector< unsigned int > *)jarg1;
80489   arg2 = (int)jarg2;
80490   temp3 = (unsigned int)jarg3;
80491   arg3 = &temp3;
80492   {
80493     try {
80494       try {
80495         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
80496       }
80497       catch(std::out_of_range &_e) {
80498         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80499         return ;
80500       }
80501
80502     } catch (std::out_of_range& e) {
80503       {
80504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80505       };
80506     } catch (std::exception& e) {
80507       {
80508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80509       };
80510     } catch (...) {
80511       {
80512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80513       };
80514     }
80515   }
80516 }
80517
80518
80519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
80520   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80521   int arg2 ;
80522   std::vector< unsigned int > *arg3 = 0 ;
80523
80524   arg1 = (std::vector< unsigned int > *)jarg1;
80525   arg2 = (int)jarg2;
80526   arg3 = (std::vector< unsigned int > *)jarg3;
80527   if (!arg3) {
80528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80529     return ;
80530   }
80531   {
80532     try {
80533       try {
80534         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80535       }
80536       catch(std::out_of_range &_e) {
80537         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80538         return ;
80539       }
80540
80541     } catch (std::out_of_range& e) {
80542       {
80543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80544       };
80545     } catch (std::exception& e) {
80546       {
80547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80548       };
80549     } catch (...) {
80550       {
80551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80552       };
80553     }
80554   }
80555 }
80556
80557
80558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
80559   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80560   int arg2 ;
80561
80562   arg1 = (std::vector< unsigned int > *)jarg1;
80563   arg2 = (int)jarg2;
80564   {
80565     try {
80566       try {
80567         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
80568       }
80569       catch(std::out_of_range &_e) {
80570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80571         return ;
80572       }
80573
80574     } catch (std::out_of_range& e) {
80575       {
80576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80577       };
80578     } catch (std::exception& e) {
80579       {
80580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80581       };
80582     } catch (...) {
80583       {
80584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80585       };
80586     }
80587   }
80588 }
80589
80590
80591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
80592   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80593   int arg2 ;
80594   int arg3 ;
80595
80596   arg1 = (std::vector< unsigned int > *)jarg1;
80597   arg2 = (int)jarg2;
80598   arg3 = (int)jarg3;
80599   {
80600     try {
80601       try {
80602         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
80603       }
80604       catch(std::out_of_range &_e) {
80605         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80606         return ;
80607       }
80608       catch(std::invalid_argument &_e) {
80609         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80610         return ;
80611       }
80612
80613     } catch (std::out_of_range& e) {
80614       {
80615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80616       };
80617     } catch (std::exception& e) {
80618       {
80619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80620       };
80621     } catch (...) {
80622       {
80623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80624       };
80625     }
80626   }
80627 }
80628
80629
80630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
80631   void * jresult ;
80632   unsigned int *arg1 = 0 ;
80633   int arg2 ;
80634   unsigned int temp1 ;
80635   std::vector< unsigned int > *result = 0 ;
80636
80637   temp1 = (unsigned int)jarg1;
80638   arg1 = &temp1;
80639   arg2 = (int)jarg2;
80640   {
80641     try {
80642       try {
80643         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
80644       }
80645       catch(std::out_of_range &_e) {
80646         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80647         return 0;
80648       }
80649
80650     } catch (std::out_of_range& e) {
80651       {
80652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80653       };
80654     } catch (std::exception& e) {
80655       {
80656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80657       };
80658     } catch (...) {
80659       {
80660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80661       };
80662     }
80663   }
80664   jresult = (void *)result;
80665   return jresult;
80666 }
80667
80668
80669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
80670   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80671
80672   arg1 = (std::vector< unsigned int > *)jarg1;
80673   {
80674     try {
80675       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
80676     } catch (std::out_of_range& e) {
80677       {
80678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80679       };
80680     } catch (std::exception& e) {
80681       {
80682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80683       };
80684     } catch (...) {
80685       {
80686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80687       };
80688     }
80689   }
80690 }
80691
80692
80693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
80694   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80695   int arg2 ;
80696   int arg3 ;
80697
80698   arg1 = (std::vector< unsigned int > *)jarg1;
80699   arg2 = (int)jarg2;
80700   arg3 = (int)jarg3;
80701   {
80702     try {
80703       try {
80704         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
80705       }
80706       catch(std::out_of_range &_e) {
80707         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80708         return ;
80709       }
80710       catch(std::invalid_argument &_e) {
80711         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80712         return ;
80713       }
80714
80715     } catch (std::out_of_range& e) {
80716       {
80717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80718       };
80719     } catch (std::exception& e) {
80720       {
80721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80722       };
80723     } catch (...) {
80724       {
80725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80726       };
80727     }
80728   }
80729 }
80730
80731
80732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
80733   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80734   int arg2 ;
80735   std::vector< unsigned int > *arg3 = 0 ;
80736
80737   arg1 = (std::vector< unsigned int > *)jarg1;
80738   arg2 = (int)jarg2;
80739   arg3 = (std::vector< unsigned int > *)jarg3;
80740   if (!arg3) {
80741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80742     return ;
80743   }
80744   {
80745     try {
80746       try {
80747         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80748       }
80749       catch(std::out_of_range &_e) {
80750         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80751         return ;
80752       }
80753
80754     } catch (std::out_of_range& e) {
80755       {
80756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80757       };
80758     } catch (std::exception& e) {
80759       {
80760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80761       };
80762     } catch (...) {
80763       {
80764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80765       };
80766     }
80767   }
80768 }
80769
80770
80771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
80772   unsigned int jresult ;
80773   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80774   unsigned int *arg2 = 0 ;
80775   unsigned int temp2 ;
80776   bool result;
80777
80778   arg1 = (std::vector< unsigned int > *)jarg1;
80779   temp2 = (unsigned int)jarg2;
80780   arg2 = &temp2;
80781   {
80782     try {
80783       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
80784     } catch (std::out_of_range& e) {
80785       {
80786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80787       };
80788     } catch (std::exception& e) {
80789       {
80790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80791       };
80792     } catch (...) {
80793       {
80794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80795       };
80796     }
80797   }
80798   jresult = result;
80799   return jresult;
80800 }
80801
80802
80803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
80804   int jresult ;
80805   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80806   unsigned int *arg2 = 0 ;
80807   unsigned int temp2 ;
80808   int result;
80809
80810   arg1 = (std::vector< unsigned int > *)jarg1;
80811   temp2 = (unsigned int)jarg2;
80812   arg2 = &temp2;
80813   {
80814     try {
80815       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
80816     } catch (std::out_of_range& e) {
80817       {
80818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80819       };
80820     } catch (std::exception& e) {
80821       {
80822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80823       };
80824     } catch (...) {
80825       {
80826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80827       };
80828     }
80829   }
80830   jresult = result;
80831   return jresult;
80832 }
80833
80834
80835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
80836   int jresult ;
80837   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80838   unsigned int *arg2 = 0 ;
80839   unsigned int temp2 ;
80840   int result;
80841
80842   arg1 = (std::vector< unsigned int > *)jarg1;
80843   temp2 = (unsigned int)jarg2;
80844   arg2 = &temp2;
80845   {
80846     try {
80847       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
80848     } catch (std::out_of_range& e) {
80849       {
80850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80851       };
80852     } catch (std::exception& e) {
80853       {
80854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80855       };
80856     } catch (...) {
80857       {
80858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80859       };
80860     }
80861   }
80862   jresult = result;
80863   return jresult;
80864 }
80865
80866
80867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
80868   unsigned int jresult ;
80869   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80870   unsigned int *arg2 = 0 ;
80871   unsigned int temp2 ;
80872   bool result;
80873
80874   arg1 = (std::vector< unsigned int > *)jarg1;
80875   temp2 = (unsigned int)jarg2;
80876   arg2 = &temp2;
80877   {
80878     try {
80879       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
80880     } catch (std::out_of_range& e) {
80881       {
80882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80883       };
80884     } catch (std::exception& e) {
80885       {
80886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80887       };
80888     } catch (...) {
80889       {
80890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80891       };
80892     }
80893   }
80894   jresult = result;
80895   return jresult;
80896 }
80897
80898
80899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
80900   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80901
80902   arg1 = (std::vector< unsigned int > *)jarg1;
80903   {
80904     try {
80905       delete arg1;
80906     } catch (std::out_of_range& e) {
80907       {
80908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80909       };
80910     } catch (std::exception& e) {
80911       {
80912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80913       };
80914     } catch (...) {
80915       {
80916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80917       };
80918     }
80919   }
80920 }
80921
80922
80923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
80924   void * jresult ;
80925   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80926
80927   {
80928     try {
80929       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
80930     } catch (std::out_of_range& e) {
80931       {
80932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80933       };
80934     } catch (std::exception& e) {
80935       {
80936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80937       };
80938     } catch (...) {
80939       {
80940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80941       };
80942     }
80943   }
80944   jresult = (void *)result;
80945   return jresult;
80946 }
80947
80948
80949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
80950   void * jresult ;
80951   unsigned int arg1 ;
80952   Dali::Actor arg2 ;
80953   Dali::Actor *argp2 ;
80954   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80955
80956   arg1 = (unsigned int)jarg1;
80957   argp2 = (Dali::Actor *)jarg2;
80958   if (!argp2) {
80959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80960     return 0;
80961   }
80962   arg2 = *argp2;
80963   {
80964     try {
80965       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
80966     } catch (std::out_of_range& e) {
80967       {
80968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80969       };
80970     } catch (std::exception& e) {
80971       {
80972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80973       };
80974     } catch (...) {
80975       {
80976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80977       };
80978     }
80979   }
80980   jresult = (void *)result;
80981   return jresult;
80982 }
80983
80984
80985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
80986   void * jresult ;
80987   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
80988   std::pair< unsigned int,Dali::Actor > *result = 0 ;
80989
80990   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
80991   if (!arg1) {
80992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
80993     return 0;
80994   }
80995   {
80996     try {
80997       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
80998     } catch (std::out_of_range& e) {
80999       {
81000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81001       };
81002     } catch (std::exception& e) {
81003       {
81004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81005       };
81006     } catch (...) {
81007       {
81008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81009       };
81010     }
81011   }
81012   jresult = (void *)result;
81013   return jresult;
81014 }
81015
81016
81017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
81018   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81019   unsigned int arg2 ;
81020
81021   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81022   arg2 = (unsigned int)jarg2;
81023   if (arg1) (arg1)->first = arg2;
81024 }
81025
81026
81027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
81028   unsigned int jresult ;
81029   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81030   unsigned int result;
81031
81032   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81033   result = (unsigned int) ((arg1)->first);
81034   jresult = result;
81035   return jresult;
81036 }
81037
81038
81039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
81040   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81041   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
81042
81043   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81044   arg2 = (Dali::Actor *)jarg2;
81045   if (arg1) (arg1)->second = *arg2;
81046 }
81047
81048
81049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
81050   void * jresult ;
81051   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81052   Dali::Actor *result = 0 ;
81053
81054   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81055   result = (Dali::Actor *)& ((arg1)->second);
81056   jresult = (void *)result;
81057   return jresult;
81058 }
81059
81060
81061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
81062   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81063
81064   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81065   {
81066     try {
81067       delete arg1;
81068     } catch (std::out_of_range& e) {
81069       {
81070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81071       };
81072     } catch (std::exception& e) {
81073       {
81074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81075       };
81076     } catch (...) {
81077       {
81078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81079       };
81080     }
81081   }
81082 }
81083
81084
81085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
81086   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81087
81088   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81089   {
81090     try {
81091       (arg1)->clear();
81092     } catch (std::out_of_range& e) {
81093       {
81094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81095       };
81096     } catch (std::exception& e) {
81097       {
81098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81099       };
81100     } catch (...) {
81101       {
81102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81103       };
81104     }
81105   }
81106 }
81107
81108
81109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
81110   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81111   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
81112
81113   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81114   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
81115   if (!arg2) {
81116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81117     return ;
81118   }
81119   {
81120     try {
81121       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
81122     } catch (std::out_of_range& e) {
81123       {
81124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81125       };
81126     } catch (std::exception& e) {
81127       {
81128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81129       };
81130     } catch (...) {
81131       {
81132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81133       };
81134     }
81135   }
81136 }
81137
81138
81139 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
81140   unsigned long jresult ;
81141   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81142   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81143
81144   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81145   {
81146     try {
81147       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
81148     } catch (std::out_of_range& e) {
81149       {
81150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81151       };
81152     } catch (std::exception& e) {
81153       {
81154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81155       };
81156     } catch (...) {
81157       {
81158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81159       };
81160     }
81161   }
81162   jresult = (unsigned long)result;
81163   return jresult;
81164 }
81165
81166
81167 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
81168   unsigned long jresult ;
81169   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81170   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81171
81172   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81173   {
81174     try {
81175       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
81176     } catch (std::out_of_range& e) {
81177       {
81178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81179       };
81180     } catch (std::exception& e) {
81181       {
81182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81183       };
81184     } catch (...) {
81185       {
81186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81187       };
81188     }
81189   }
81190   jresult = (unsigned long)result;
81191   return jresult;
81192 }
81193
81194
81195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
81196   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81197   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
81198
81199   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81200   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
81201   {
81202     try {
81203       (arg1)->reserve(arg2);
81204     } catch (std::out_of_range& e) {
81205       {
81206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81207       };
81208     } catch (std::exception& e) {
81209       {
81210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81211       };
81212     } catch (...) {
81213       {
81214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81215       };
81216     }
81217   }
81218 }
81219
81220
81221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
81222   void * jresult ;
81223   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81224
81225   {
81226     try {
81227       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
81228     } catch (std::out_of_range& e) {
81229       {
81230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81231       };
81232     } catch (std::exception& e) {
81233       {
81234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81235       };
81236     } catch (...) {
81237       {
81238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81239       };
81240     }
81241   }
81242   jresult = (void *)result;
81243   return jresult;
81244 }
81245
81246
81247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
81248   void * jresult ;
81249   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
81250   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81251
81252   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81253   if (!arg1) {
81254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81255     return 0;
81256   }
81257   {
81258     try {
81259       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);
81260     } catch (std::out_of_range& e) {
81261       {
81262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81263       };
81264     } catch (std::exception& e) {
81265       {
81266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81267       };
81268     } catch (...) {
81269       {
81270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81271       };
81272     }
81273   }
81274   jresult = (void *)result;
81275   return jresult;
81276 }
81277
81278
81279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
81280   void * jresult ;
81281   int arg1 ;
81282   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81283
81284   arg1 = (int)jarg1;
81285   {
81286     try {
81287       try {
81288         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);
81289       }
81290       catch(std::out_of_range &_e) {
81291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81292         return 0;
81293       }
81294
81295     } catch (std::out_of_range& e) {
81296       {
81297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81298       };
81299     } catch (std::exception& e) {
81300       {
81301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81302       };
81303     } catch (...) {
81304       {
81305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81306       };
81307     }
81308   }
81309   jresult = (void *)result;
81310   return jresult;
81311 }
81312
81313
81314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
81315   void * jresult ;
81316   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81317   int arg2 ;
81318   std::pair< unsigned int,Dali::Actor > result;
81319
81320   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81321   arg2 = (int)jarg2;
81322   {
81323     try {
81324       try {
81325         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
81326       }
81327       catch(std::out_of_range &_e) {
81328         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81329         return 0;
81330       }
81331
81332     } catch (std::out_of_range& e) {
81333       {
81334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81335       };
81336     } catch (std::exception& e) {
81337       {
81338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81339       };
81340     } catch (...) {
81341       {
81342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81343       };
81344     }
81345   }
81346   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
81347   return jresult;
81348 }
81349
81350
81351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
81352   void * jresult ;
81353   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81354   int arg2 ;
81355   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81356
81357   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81358   arg2 = (int)jarg2;
81359   {
81360     try {
81361       try {
81362         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
81363       }
81364       catch(std::out_of_range &_e) {
81365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81366         return 0;
81367       }
81368
81369     } catch (std::out_of_range& e) {
81370       {
81371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81372       };
81373     } catch (std::exception& e) {
81374       {
81375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81376       };
81377     } catch (...) {
81378       {
81379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81380       };
81381     }
81382   }
81383   jresult = (void *)result;
81384   return jresult;
81385 }
81386
81387
81388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
81389   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81390   int arg2 ;
81391   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81392
81393   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81394   arg2 = (int)jarg2;
81395   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81396   if (!arg3) {
81397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81398     return ;
81399   }
81400   {
81401     try {
81402       try {
81403         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);
81404       }
81405       catch(std::out_of_range &_e) {
81406         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81407         return ;
81408       }
81409
81410     } catch (std::out_of_range& e) {
81411       {
81412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81413       };
81414     } catch (std::exception& e) {
81415       {
81416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81417       };
81418     } catch (...) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81421       };
81422     }
81423   }
81424 }
81425
81426
81427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
81428   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81429   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
81430
81431   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81432   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
81433   if (!arg2) {
81434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81435     return ;
81436   }
81437   {
81438     try {
81439       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);
81440     } catch (std::out_of_range& e) {
81441       {
81442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81443       };
81444     } catch (std::exception& e) {
81445       {
81446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81447       };
81448     } catch (...) {
81449       {
81450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81451       };
81452     }
81453   }
81454 }
81455
81456
81457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
81458   void * jresult ;
81459   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81460   int arg2 ;
81461   int arg3 ;
81462   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81463
81464   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81465   arg2 = (int)jarg2;
81466   arg3 = (int)jarg3;
81467   {
81468     try {
81469       try {
81470         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);
81471       }
81472       catch(std::out_of_range &_e) {
81473         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81474         return 0;
81475       }
81476       catch(std::invalid_argument &_e) {
81477         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81478         return 0;
81479       }
81480
81481     } catch (std::out_of_range& e) {
81482       {
81483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81484       };
81485     } catch (std::exception& e) {
81486       {
81487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81488       };
81489     } catch (...) {
81490       {
81491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81492       };
81493     }
81494   }
81495   jresult = (void *)result;
81496   return jresult;
81497 }
81498
81499
81500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
81501   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81502   int arg2 ;
81503   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81504
81505   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81506   arg2 = (int)jarg2;
81507   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81508   if (!arg3) {
81509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81510     return ;
81511   }
81512   {
81513     try {
81514       try {
81515         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);
81516       }
81517       catch(std::out_of_range &_e) {
81518         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81519         return ;
81520       }
81521
81522     } catch (std::out_of_range& e) {
81523       {
81524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81525       };
81526     } catch (std::exception& e) {
81527       {
81528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81529       };
81530     } catch (...) {
81531       {
81532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81533       };
81534     }
81535   }
81536 }
81537
81538
81539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
81540   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81541   int arg2 ;
81542   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81543
81544   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81545   arg2 = (int)jarg2;
81546   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81547   if (!arg3) {
81548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81549     return ;
81550   }
81551   {
81552     try {
81553       try {
81554         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);
81555       }
81556       catch(std::out_of_range &_e) {
81557         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81558         return ;
81559       }
81560
81561     } catch (std::out_of_range& e) {
81562       {
81563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81564       };
81565     } catch (std::exception& e) {
81566       {
81567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81568       };
81569     } catch (...) {
81570       {
81571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81572       };
81573     }
81574   }
81575 }
81576
81577
81578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
81579   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81580   int arg2 ;
81581
81582   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81583   arg2 = (int)jarg2;
81584   {
81585     try {
81586       try {
81587         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
81588       }
81589       catch(std::out_of_range &_e) {
81590         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81591         return ;
81592       }
81593
81594     } catch (std::out_of_range& e) {
81595       {
81596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81597       };
81598     } catch (std::exception& e) {
81599       {
81600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81601       };
81602     } catch (...) {
81603       {
81604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81605       };
81606     }
81607   }
81608 }
81609
81610
81611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
81612   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81613   int arg2 ;
81614   int arg3 ;
81615
81616   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81617   arg2 = (int)jarg2;
81618   arg3 = (int)jarg3;
81619   {
81620     try {
81621       try {
81622         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
81623       }
81624       catch(std::out_of_range &_e) {
81625         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81626         return ;
81627       }
81628       catch(std::invalid_argument &_e) {
81629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81630         return ;
81631       }
81632
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_ItemContainer_Repeat(void * jarg1, int jarg2) {
81651   void * jresult ;
81652   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81653   int arg2 ;
81654   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81655
81656   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81657   if (!arg1) {
81658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81659     return 0;
81660   }
81661   arg2 = (int)jarg2;
81662   {
81663     try {
81664       try {
81665         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);
81666       }
81667       catch(std::out_of_range &_e) {
81668         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81669         return 0;
81670       }
81671
81672     } catch (std::out_of_range& e) {
81673       {
81674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81675       };
81676     } catch (std::exception& e) {
81677       {
81678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81679       };
81680     } catch (...) {
81681       {
81682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81683       };
81684     }
81685   }
81686   jresult = (void *)result;
81687   return jresult;
81688 }
81689
81690
81691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
81692   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81693
81694   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81695   {
81696     try {
81697       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
81698     } catch (std::out_of_range& e) {
81699       {
81700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81701       };
81702     } catch (std::exception& e) {
81703       {
81704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81705       };
81706     } catch (...) {
81707       {
81708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81709       };
81710     }
81711   }
81712 }
81713
81714
81715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
81716   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81717   int arg2 ;
81718   int arg3 ;
81719
81720   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81721   arg2 = (int)jarg2;
81722   arg3 = (int)jarg3;
81723   {
81724     try {
81725       try {
81726         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
81727       }
81728       catch(std::out_of_range &_e) {
81729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81730         return ;
81731       }
81732       catch(std::invalid_argument &_e) {
81733         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81734         return ;
81735       }
81736
81737     } catch (std::out_of_range& e) {
81738       {
81739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81740       };
81741     } catch (std::exception& e) {
81742       {
81743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81744       };
81745     } catch (...) {
81746       {
81747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81748       };
81749     }
81750   }
81751 }
81752
81753
81754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
81755   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81756   int arg2 ;
81757   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81758
81759   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81760   arg2 = (int)jarg2;
81761   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81762   if (!arg3) {
81763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81764     return ;
81765   }
81766   {
81767     try {
81768       try {
81769         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);
81770       }
81771       catch(std::out_of_range &_e) {
81772         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81773         return ;
81774       }
81775
81776     } catch (std::out_of_range& e) {
81777       {
81778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81779       };
81780     } catch (std::exception& e) {
81781       {
81782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81783       };
81784     } catch (...) {
81785       {
81786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81787       };
81788     }
81789   }
81790 }
81791
81792
81793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
81794   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81795
81796   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81797   {
81798     try {
81799       delete arg1;
81800     } catch (std::out_of_range& e) {
81801       {
81802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81803       };
81804     } catch (std::exception& e) {
81805       {
81806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81807       };
81808     } catch (...) {
81809       {
81810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81811       };
81812     }
81813   }
81814 }
81815
81816
81817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
81818   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81819
81820   arg1 = (std::vector< Dali::Actor > *)jarg1;
81821   {
81822     try {
81823       (arg1)->clear();
81824     } catch (std::out_of_range& e) {
81825       {
81826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81827       };
81828     } catch (std::exception& e) {
81829       {
81830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81831       };
81832     } catch (...) {
81833       {
81834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81835       };
81836     }
81837   }
81838 }
81839
81840
81841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
81842   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81843   Dali::Actor *arg2 = 0 ;
81844
81845   arg1 = (std::vector< Dali::Actor > *)jarg1;
81846   arg2 = (Dali::Actor *)jarg2;
81847   if (!arg2) {
81848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
81849     return ;
81850   }
81851   {
81852     try {
81853       (arg1)->push_back((Dali::Actor const &)*arg2);
81854     } catch (std::out_of_range& e) {
81855       {
81856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81857       };
81858     } catch (std::exception& e) {
81859       {
81860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81861       };
81862     } catch (...) {
81863       {
81864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81865       };
81866     }
81867   }
81868 }
81869
81870
81871 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
81872   unsigned long jresult ;
81873   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81874   std::vector< Dali::Actor >::size_type result;
81875
81876   arg1 = (std::vector< Dali::Actor > *)jarg1;
81877   {
81878     try {
81879       result = ((std::vector< Dali::Actor > const *)arg1)->size();
81880     } catch (std::out_of_range& e) {
81881       {
81882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81883       };
81884     } catch (std::exception& e) {
81885       {
81886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81887       };
81888     } catch (...) {
81889       {
81890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81891       };
81892     }
81893   }
81894   jresult = (unsigned long)result;
81895   return jresult;
81896 }
81897
81898
81899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
81900   unsigned long jresult ;
81901   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81902   std::vector< Dali::Actor >::size_type result;
81903
81904   arg1 = (std::vector< Dali::Actor > *)jarg1;
81905   {
81906     try {
81907       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
81908     } catch (std::out_of_range& e) {
81909       {
81910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81911       };
81912     } catch (std::exception& e) {
81913       {
81914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81915       };
81916     } catch (...) {
81917       {
81918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81919       };
81920     }
81921   }
81922   jresult = (unsigned long)result;
81923   return jresult;
81924 }
81925
81926
81927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
81928   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81929   std::vector< Dali::Actor >::size_type arg2 ;
81930
81931   arg1 = (std::vector< Dali::Actor > *)jarg1;
81932   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
81933   {
81934     try {
81935       (arg1)->reserve(arg2);
81936     } catch (std::out_of_range& e) {
81937       {
81938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81939       };
81940     } catch (std::exception& e) {
81941       {
81942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81943       };
81944     } catch (...) {
81945       {
81946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81947       };
81948     }
81949   }
81950 }
81951
81952
81953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
81954   void * jresult ;
81955   std::vector< Dali::Actor > *result = 0 ;
81956
81957   {
81958     try {
81959       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
81960     } catch (std::out_of_range& e) {
81961       {
81962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81963       };
81964     } catch (std::exception& e) {
81965       {
81966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81967       };
81968     } catch (...) {
81969       {
81970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81971       };
81972     }
81973   }
81974   jresult = (void *)result;
81975   return jresult;
81976 }
81977
81978
81979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
81980   void * jresult ;
81981   std::vector< Dali::Actor > *arg1 = 0 ;
81982   std::vector< Dali::Actor > *result = 0 ;
81983
81984   arg1 = (std::vector< Dali::Actor > *)jarg1;
81985   if (!arg1) {
81986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
81987     return 0;
81988   }
81989   {
81990     try {
81991       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
81992     } catch (std::out_of_range& e) {
81993       {
81994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81995       };
81996     } catch (std::exception& e) {
81997       {
81998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81999       };
82000     } catch (...) {
82001       {
82002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82003       };
82004     }
82005   }
82006   jresult = (void *)result;
82007   return jresult;
82008 }
82009
82010
82011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
82012   void * jresult ;
82013   int arg1 ;
82014   std::vector< Dali::Actor > *result = 0 ;
82015
82016   arg1 = (int)jarg1;
82017   {
82018     try {
82019       try {
82020         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
82021       }
82022       catch(std::out_of_range &_e) {
82023         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82024         return 0;
82025       }
82026
82027     } catch (std::out_of_range& e) {
82028       {
82029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82030       };
82031     } catch (std::exception& e) {
82032       {
82033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82034       };
82035     } catch (...) {
82036       {
82037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82038       };
82039     }
82040   }
82041   jresult = (void *)result;
82042   return jresult;
82043 }
82044
82045
82046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
82047   void * jresult ;
82048   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82049   int arg2 ;
82050   Dali::Actor result;
82051
82052   arg1 = (std::vector< Dali::Actor > *)jarg1;
82053   arg2 = (int)jarg2;
82054   {
82055     try {
82056       try {
82057         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
82058       }
82059       catch(std::out_of_range &_e) {
82060         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82061         return 0;
82062       }
82063
82064     } catch (std::out_of_range& e) {
82065       {
82066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82067       };
82068     } catch (std::exception& e) {
82069       {
82070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82071       };
82072     } catch (...) {
82073       {
82074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82075       };
82076     }
82077   }
82078   jresult = new Dali::Actor((const Dali::Actor &)result);
82079   return jresult;
82080 }
82081
82082
82083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
82084   void * jresult ;
82085   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82086   int arg2 ;
82087   Dali::Actor *result = 0 ;
82088
82089   arg1 = (std::vector< Dali::Actor > *)jarg1;
82090   arg2 = (int)jarg2;
82091   {
82092     try {
82093       try {
82094         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
82095       }
82096       catch(std::out_of_range &_e) {
82097         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82098         return 0;
82099       }
82100
82101     } catch (std::out_of_range& e) {
82102       {
82103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82104       };
82105     } catch (std::exception& e) {
82106       {
82107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82108       };
82109     } catch (...) {
82110       {
82111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82112       };
82113     }
82114   }
82115   jresult = (void *)result;
82116   return jresult;
82117 }
82118
82119
82120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
82121   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82122   int arg2 ;
82123   Dali::Actor *arg3 = 0 ;
82124
82125   arg1 = (std::vector< Dali::Actor > *)jarg1;
82126   arg2 = (int)jarg2;
82127   arg3 = (Dali::Actor *)jarg3;
82128   if (!arg3) {
82129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82130     return ;
82131   }
82132   {
82133     try {
82134       try {
82135         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
82136       }
82137       catch(std::out_of_range &_e) {
82138         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82139         return ;
82140       }
82141
82142     } catch (std::out_of_range& e) {
82143       {
82144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82145       };
82146     } catch (std::exception& e) {
82147       {
82148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82149       };
82150     } catch (...) {
82151       {
82152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82153       };
82154     }
82155   }
82156 }
82157
82158
82159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
82160   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82161   std::vector< Dali::Actor > *arg2 = 0 ;
82162
82163   arg1 = (std::vector< Dali::Actor > *)jarg1;
82164   arg2 = (std::vector< Dali::Actor > *)jarg2;
82165   if (!arg2) {
82166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82167     return ;
82168   }
82169   {
82170     try {
82171       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
82172     } catch (std::out_of_range& e) {
82173       {
82174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82175       };
82176     } catch (std::exception& e) {
82177       {
82178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82179       };
82180     } catch (...) {
82181       {
82182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82183       };
82184     }
82185   }
82186 }
82187
82188
82189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82190   void * jresult ;
82191   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82192   int arg2 ;
82193   int arg3 ;
82194   std::vector< Dali::Actor > *result = 0 ;
82195
82196   arg1 = (std::vector< Dali::Actor > *)jarg1;
82197   arg2 = (int)jarg2;
82198   arg3 = (int)jarg3;
82199   {
82200     try {
82201       try {
82202         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
82203       }
82204       catch(std::out_of_range &_e) {
82205         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82206         return 0;
82207       }
82208       catch(std::invalid_argument &_e) {
82209         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82210         return 0;
82211       }
82212
82213     } catch (std::out_of_range& e) {
82214       {
82215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82216       };
82217     } catch (std::exception& e) {
82218       {
82219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82220       };
82221     } catch (...) {
82222       {
82223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82224       };
82225     }
82226   }
82227   jresult = (void *)result;
82228   return jresult;
82229 }
82230
82231
82232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
82233   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82234   int arg2 ;
82235   Dali::Actor *arg3 = 0 ;
82236
82237   arg1 = (std::vector< Dali::Actor > *)jarg1;
82238   arg2 = (int)jarg2;
82239   arg3 = (Dali::Actor *)jarg3;
82240   if (!arg3) {
82241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82242     return ;
82243   }
82244   {
82245     try {
82246       try {
82247         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
82248       }
82249       catch(std::out_of_range &_e) {
82250         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82251         return ;
82252       }
82253
82254     } catch (std::out_of_range& e) {
82255       {
82256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82257       };
82258     } catch (std::exception& e) {
82259       {
82260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82261       };
82262     } catch (...) {
82263       {
82264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82265       };
82266     }
82267   }
82268 }
82269
82270
82271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82272   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82273   int arg2 ;
82274   std::vector< Dali::Actor > *arg3 = 0 ;
82275
82276   arg1 = (std::vector< Dali::Actor > *)jarg1;
82277   arg2 = (int)jarg2;
82278   arg3 = (std::vector< Dali::Actor > *)jarg3;
82279   if (!arg3) {
82280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82281     return ;
82282   }
82283   {
82284     try {
82285       try {
82286         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82287       }
82288       catch(std::out_of_range &_e) {
82289         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82290         return ;
82291       }
82292
82293     } catch (std::out_of_range& e) {
82294       {
82295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82296       };
82297     } catch (std::exception& e) {
82298       {
82299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82300       };
82301     } catch (...) {
82302       {
82303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82304       };
82305     }
82306   }
82307 }
82308
82309
82310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
82311   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82312   int arg2 ;
82313
82314   arg1 = (std::vector< Dali::Actor > *)jarg1;
82315   arg2 = (int)jarg2;
82316   {
82317     try {
82318       try {
82319         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
82320       }
82321       catch(std::out_of_range &_e) {
82322         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82323         return ;
82324       }
82325
82326     } catch (std::out_of_range& e) {
82327       {
82328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82329       };
82330     } catch (std::exception& e) {
82331       {
82332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82333       };
82334     } catch (...) {
82335       {
82336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82337       };
82338     }
82339   }
82340 }
82341
82342
82343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82344   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82345   int arg2 ;
82346   int arg3 ;
82347
82348   arg1 = (std::vector< Dali::Actor > *)jarg1;
82349   arg2 = (int)jarg2;
82350   arg3 = (int)jarg3;
82351   {
82352     try {
82353       try {
82354         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
82355       }
82356       catch(std::out_of_range &_e) {
82357         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82358         return ;
82359       }
82360       catch(std::invalid_argument &_e) {
82361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82362         return ;
82363       }
82364
82365     } catch (std::out_of_range& e) {
82366       {
82367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82368       };
82369     } catch (std::exception& e) {
82370       {
82371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82372       };
82373     } catch (...) {
82374       {
82375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82376       };
82377     }
82378   }
82379 }
82380
82381
82382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
82383   void * jresult ;
82384   Dali::Actor *arg1 = 0 ;
82385   int arg2 ;
82386   std::vector< Dali::Actor > *result = 0 ;
82387
82388   arg1 = (Dali::Actor *)jarg1;
82389   if (!arg1) {
82390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82391     return 0;
82392   }
82393   arg2 = (int)jarg2;
82394   {
82395     try {
82396       try {
82397         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
82398       }
82399       catch(std::out_of_range &_e) {
82400         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82401         return 0;
82402       }
82403
82404     } catch (std::out_of_range& e) {
82405       {
82406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82407       };
82408     } catch (std::exception& e) {
82409       {
82410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82411       };
82412     } catch (...) {
82413       {
82414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82415       };
82416     }
82417   }
82418   jresult = (void *)result;
82419   return jresult;
82420 }
82421
82422
82423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
82424   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82425
82426   arg1 = (std::vector< Dali::Actor > *)jarg1;
82427   {
82428     try {
82429       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
82430     } catch (std::out_of_range& e) {
82431       {
82432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82433       };
82434     } catch (std::exception& e) {
82435       {
82436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82437       };
82438     } catch (...) {
82439       {
82440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82441       };
82442     }
82443   }
82444 }
82445
82446
82447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82448   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82449   int arg2 ;
82450   int arg3 ;
82451
82452   arg1 = (std::vector< Dali::Actor > *)jarg1;
82453   arg2 = (int)jarg2;
82454   arg3 = (int)jarg3;
82455   {
82456     try {
82457       try {
82458         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82459       }
82460       catch(std::out_of_range &_e) {
82461         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82462         return ;
82463       }
82464       catch(std::invalid_argument &_e) {
82465         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82466         return ;
82467       }
82468
82469     } catch (std::out_of_range& e) {
82470       {
82471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82472       };
82473     } catch (std::exception& e) {
82474       {
82475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82476       };
82477     } catch (...) {
82478       {
82479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82480       };
82481     }
82482   }
82483 }
82484
82485
82486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82487   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82488   int arg2 ;
82489   std::vector< Dali::Actor > *arg3 = 0 ;
82490
82491   arg1 = (std::vector< Dali::Actor > *)jarg1;
82492   arg2 = (int)jarg2;
82493   arg3 = (std::vector< Dali::Actor > *)jarg3;
82494   if (!arg3) {
82495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82496     return ;
82497   }
82498   {
82499     try {
82500       try {
82501         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82502       }
82503       catch(std::out_of_range &_e) {
82504         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82505         return ;
82506       }
82507
82508     } catch (std::out_of_range& e) {
82509       {
82510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82511       };
82512     } catch (std::exception& e) {
82513       {
82514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82515       };
82516     } catch (...) {
82517       {
82518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82519       };
82520     }
82521   }
82522 }
82523
82524
82525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
82526   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82527
82528   arg1 = (std::vector< Dali::Actor > *)jarg1;
82529   {
82530     try {
82531       delete arg1;
82532     } catch (std::out_of_range& e) {
82533       {
82534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82535       };
82536     } catch (std::exception& e) {
82537       {
82538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82539       };
82540     } catch (...) {
82541       {
82542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82543       };
82544     }
82545   }
82546 }
82547
82548
82549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
82550   unsigned int jresult ;
82551   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82552   bool result;
82553
82554   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82555   {
82556     try {
82557       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82558     } catch (std::out_of_range& e) {
82559       {
82560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82561       };
82562     } catch (std::exception& e) {
82563       {
82564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82565       };
82566     } catch (...) {
82567       {
82568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82569       };
82570     }
82571   }
82572   jresult = result;
82573   return jresult;
82574 }
82575
82576
82577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
82578   unsigned long jresult ;
82579   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82580   std::size_t result;
82581
82582   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82583   {
82584     try {
82585       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82586     } catch (std::out_of_range& e) {
82587       {
82588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82589       };
82590     } catch (std::exception& e) {
82591       {
82592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82593       };
82594     } catch (...) {
82595       {
82596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82597       };
82598     }
82599   }
82600   jresult = (unsigned long)result;
82601   return jresult;
82602 }
82603
82604
82605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
82606   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82607   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82608
82609   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82610   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82611   {
82612     try {
82613       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
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_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
82632   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82633   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82634
82635   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82636   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82637   {
82638     try {
82639       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
82640     } catch (std::out_of_range& e) {
82641       {
82642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82643       };
82644     } catch (std::exception& e) {
82645       {
82646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82647       };
82648     } catch (...) {
82649       {
82650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82651       };
82652     }
82653   }
82654 }
82655
82656
82657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
82658   unsigned int jresult ;
82659   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82660   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
82661   bool result;
82662
82663   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82664   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
82665   if (!arg2) {
82666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
82667     return 0;
82668   }
82669   {
82670     try {
82671       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
82672     } catch (std::out_of_range& e) {
82673       {
82674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82675       };
82676     } catch (std::exception& e) {
82677       {
82678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82679       };
82680     } catch (...) {
82681       {
82682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82683       };
82684     }
82685   }
82686   jresult = result;
82687   return jresult;
82688 }
82689
82690
82691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
82692   void * jresult ;
82693   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
82694
82695   {
82696     try {
82697       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
82698     } catch (std::out_of_range& e) {
82699       {
82700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82701       };
82702     } catch (std::exception& e) {
82703       {
82704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82705       };
82706     } catch (...) {
82707       {
82708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82709       };
82710     }
82711   }
82712   jresult = (void *)result;
82713   return jresult;
82714 }
82715
82716
82717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
82718   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82719
82720   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82721   {
82722     try {
82723       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
82742   unsigned int jresult ;
82743   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82744   bool result;
82745
82746   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82747   {
82748     try {
82749       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);
82750     } catch (std::out_of_range& e) {
82751       {
82752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82753       };
82754     } catch (std::exception& e) {
82755       {
82756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82757       };
82758     } catch (...) {
82759       {
82760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82761       };
82762     }
82763   }
82764   jresult = result;
82765   return jresult;
82766 }
82767
82768
82769 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
82770   unsigned long jresult ;
82771   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82772   std::size_t result;
82773
82774   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82775   {
82776     try {
82777       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);
82778     } catch (std::out_of_range& e) {
82779       {
82780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82781       };
82782     } catch (std::exception& e) {
82783       {
82784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82785       };
82786     } catch (...) {
82787       {
82788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82789       };
82790     }
82791   }
82792   jresult = (unsigned long)result;
82793   return jresult;
82794 }
82795
82796
82797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
82798   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82799   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82800
82801   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82802   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82803   {
82804     try {
82805       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
82806     } catch (std::out_of_range& e) {
82807       {
82808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82809       };
82810     } catch (std::exception& e) {
82811       {
82812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82813       };
82814     } catch (...) {
82815       {
82816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82817       };
82818     }
82819   }
82820 }
82821
82822
82823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
82824   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82825   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82826
82827   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82828   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82829   {
82830     try {
82831       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
82832     } catch (std::out_of_range& e) {
82833       {
82834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82835       };
82836     } catch (std::exception& e) {
82837       {
82838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82839       };
82840     } catch (...) {
82841       {
82842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82843       };
82844     }
82845   }
82846 }
82847
82848
82849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
82850   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82851   Dali::Actor arg2 ;
82852   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
82853   Dali::Actor *argp2 ;
82854
82855   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82856   argp2 = (Dali::Actor *)jarg2;
82857   if (!argp2) {
82858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82859     return ;
82860   }
82861   arg2 = *argp2;
82862   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
82863   {
82864     try {
82865       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
82866     } catch (std::out_of_range& e) {
82867       {
82868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82869       };
82870     } catch (std::exception& e) {
82871       {
82872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82873       };
82874     } catch (...) {
82875       {
82876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82877       };
82878     }
82879   }
82880 }
82881
82882
82883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
82884   void * jresult ;
82885   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
82886
82887   {
82888     try {
82889       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
82890     } catch (std::out_of_range& e) {
82891       {
82892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82893       };
82894     } catch (std::exception& e) {
82895       {
82896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82897       };
82898     } catch (...) {
82899       {
82900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82901       };
82902     }
82903   }
82904   jresult = (void *)result;
82905   return jresult;
82906 }
82907
82908
82909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
82910   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82911
82912   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82913   {
82914     try {
82915       delete arg1;
82916     } catch (std::out_of_range& e) {
82917       {
82918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82919       };
82920     } catch (std::exception& e) {
82921       {
82922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82923       };
82924     } catch (...) {
82925       {
82926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82927       };
82928     }
82929   }
82930 }
82931
82932
82933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
82934   unsigned int jresult ;
82935   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82936   bool result;
82937
82938   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82939   {
82940     try {
82941       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82942     } catch (std::out_of_range& e) {
82943       {
82944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82945       };
82946     } catch (std::exception& e) {
82947       {
82948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82949       };
82950     } catch (...) {
82951       {
82952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82953       };
82954     }
82955   }
82956   jresult = result;
82957   return jresult;
82958 }
82959
82960
82961 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
82962   unsigned long jresult ;
82963   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82964   std::size_t result;
82965
82966   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82967   {
82968     try {
82969       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
82970     } catch (std::out_of_range& e) {
82971       {
82972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82973       };
82974     } catch (std::exception& e) {
82975       {
82976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82977       };
82978     } catch (...) {
82979       {
82980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82981       };
82982     }
82983   }
82984   jresult = (unsigned long)result;
82985   return jresult;
82986 }
82987
82988
82989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
82990   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
82991   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
82992
82993   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
82994   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
82995   {
82996     try {
82997       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
82998     } catch (std::out_of_range& e) {
82999       {
83000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83001       };
83002     } catch (std::exception& e) {
83003       {
83004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83005       };
83006     } catch (...) {
83007       {
83008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83009       };
83010     }
83011   }
83012 }
83013
83014
83015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83016   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83017   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
83018
83019   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83020   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
83021   {
83022     try {
83023       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
83024     } catch (std::out_of_range& e) {
83025       {
83026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83027       };
83028     } catch (std::exception& e) {
83029       {
83030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83031       };
83032     } catch (...) {
83033       {
83034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83035       };
83036     }
83037   }
83038 }
83039
83040
83041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
83042   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83043   Dali::Actor arg2 ;
83044   Dali::Actor arg3 ;
83045   Dali::Actor *argp2 ;
83046   Dali::Actor *argp3 ;
83047
83048   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83049   argp2 = (Dali::Actor *)jarg2;
83050   if (!argp2) {
83051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83052     return ;
83053   }
83054   arg2 = *argp2;
83055   argp3 = (Dali::Actor *)jarg3;
83056   if (!argp3) {
83057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83058     return ;
83059   }
83060   arg3 = *argp3;
83061   {
83062     try {
83063       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
83064     } catch (std::out_of_range& e) {
83065       {
83066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83067       };
83068     } catch (std::exception& e) {
83069       {
83070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83071       };
83072     } catch (...) {
83073       {
83074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83075       };
83076     }
83077   }
83078 }
83079
83080
83081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
83082   void * jresult ;
83083   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
83084
83085   {
83086     try {
83087       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
83088     } catch (std::out_of_range& e) {
83089       {
83090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83091       };
83092     } catch (std::exception& e) {
83093       {
83094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83095       };
83096     } catch (...) {
83097       {
83098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83099       };
83100     }
83101   }
83102   jresult = (void *)result;
83103   return jresult;
83104 }
83105
83106
83107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
83108   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83109
83110   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83111   {
83112     try {
83113       delete arg1;
83114     } catch (std::out_of_range& e) {
83115       {
83116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83117       };
83118     } catch (std::exception& e) {
83119       {
83120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83121       };
83122     } catch (...) {
83123       {
83124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83125       };
83126     }
83127   }
83128 }
83129
83130
83131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
83132   unsigned int jresult ;
83133   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83134   bool result;
83135
83136   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83137   {
83138     try {
83139       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83140     } catch (std::out_of_range& e) {
83141       {
83142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83143       };
83144     } catch (std::exception& e) {
83145       {
83146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83147       };
83148     } catch (...) {
83149       {
83150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83151       };
83152     }
83153   }
83154   jresult = result;
83155   return jresult;
83156 }
83157
83158
83159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
83160   unsigned long jresult ;
83161   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83162   std::size_t result;
83163
83164   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83165   {
83166     try {
83167       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83168     } catch (std::out_of_range& e) {
83169       {
83170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83171       };
83172     } catch (std::exception& e) {
83173       {
83174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83175       };
83176     } catch (...) {
83177       {
83178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83179       };
83180     }
83181   }
83182   jresult = (unsigned long)result;
83183   return jresult;
83184 }
83185
83186
83187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
83188   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83189   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83190
83191   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83192   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83193   {
83194     try {
83195       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
83196     } catch (std::out_of_range& e) {
83197       {
83198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83199       };
83200     } catch (std::exception& e) {
83201       {
83202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83203       };
83204     } catch (...) {
83205       {
83206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83207       };
83208     }
83209   }
83210 }
83211
83212
83213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83214   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83215   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83216
83217   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83218   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83219   {
83220     try {
83221       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83222     } catch (std::out_of_range& e) {
83223       {
83224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83225       };
83226     } catch (std::exception& e) {
83227       {
83228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83229       };
83230     } catch (...) {
83231       {
83232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83233       };
83234     }
83235   }
83236 }
83237
83238
83239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
83240   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83241   Dali::Actor arg2 ;
83242   bool arg3 ;
83243   Dali::Actor *argp2 ;
83244
83245   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83246   argp2 = (Dali::Actor *)jarg2;
83247   if (!argp2) {
83248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83249     return ;
83250   }
83251   arg2 = *argp2;
83252   arg3 = jarg3 ? true : false;
83253   {
83254     try {
83255       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
83256     } catch (std::out_of_range& e) {
83257       {
83258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83259       };
83260     } catch (std::exception& e) {
83261       {
83262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83263       };
83264     } catch (...) {
83265       {
83266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83267       };
83268     }
83269   }
83270 }
83271
83272
83273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
83274   void * jresult ;
83275   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
83276
83277   {
83278     try {
83279       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
83280     } catch (std::out_of_range& e) {
83281       {
83282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83283       };
83284     } catch (std::exception& e) {
83285       {
83286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83287       };
83288     } catch (...) {
83289       {
83290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83291       };
83292     }
83293   }
83294   jresult = (void *)result;
83295   return jresult;
83296 }
83297
83298
83299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
83300   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83301
83302   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83303   {
83304     try {
83305       delete arg1;
83306     } catch (std::out_of_range& e) {
83307       {
83308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83309       };
83310     } catch (std::exception& e) {
83311       {
83312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83313       };
83314     } catch (...) {
83315       {
83316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83317       };
83318     }
83319   }
83320 }
83321
83322
83323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
83324   unsigned int jresult ;
83325   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83326   bool result;
83327
83328   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83329   {
83330     try {
83331       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);
83332     } catch (std::out_of_range& e) {
83333       {
83334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83335       };
83336     } catch (std::exception& e) {
83337       {
83338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83339       };
83340     } catch (...) {
83341       {
83342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83343       };
83344     }
83345   }
83346   jresult = result;
83347   return jresult;
83348 }
83349
83350
83351 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
83352   unsigned long jresult ;
83353   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83354   std::size_t result;
83355
83356   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83357   {
83358     try {
83359       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);
83360     } catch (std::out_of_range& e) {
83361       {
83362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83363       };
83364     } catch (std::exception& e) {
83365       {
83366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83367       };
83368     } catch (...) {
83369       {
83370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83371       };
83372     }
83373   }
83374   jresult = (unsigned long)result;
83375   return jresult;
83376 }
83377
83378
83379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
83380   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83381   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83382
83383   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83384   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83385   {
83386     try {
83387       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
83388     } catch (std::out_of_range& e) {
83389       {
83390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83391       };
83392     } catch (std::exception& e) {
83393       {
83394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83395       };
83396     } catch (...) {
83397       {
83398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83399       };
83400     }
83401   }
83402 }
83403
83404
83405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83406   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83407   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83408
83409   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83410   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83411   {
83412     try {
83413       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
83414     } catch (std::out_of_range& e) {
83415       {
83416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83417       };
83418     } catch (std::exception& e) {
83419       {
83420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83421       };
83422     } catch (...) {
83423       {
83424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83425       };
83426     }
83427   }
83428 }
83429
83430
83431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
83432   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83433   Dali::Toolkit::StyleManager arg2 ;
83434   Dali::StyleChange::Type arg3 ;
83435   Dali::Toolkit::StyleManager *argp2 ;
83436
83437   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83438   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
83439   if (!argp2) {
83440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
83441     return ;
83442   }
83443   arg2 = *argp2;
83444   arg3 = (Dali::StyleChange::Type)jarg3;
83445   {
83446     try {
83447       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
83448     } catch (std::out_of_range& e) {
83449       {
83450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83451       };
83452     } catch (std::exception& e) {
83453       {
83454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83455       };
83456     } catch (...) {
83457       {
83458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83459       };
83460     }
83461   }
83462 }
83463
83464
83465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
83466   void * jresult ;
83467   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
83468
83469   {
83470     try {
83471       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
83472     } catch (std::out_of_range& e) {
83473       {
83474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83475       };
83476     } catch (std::exception& e) {
83477       {
83478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83479       };
83480     } catch (...) {
83481       {
83482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83483       };
83484     }
83485   }
83486   jresult = (void *)result;
83487   return jresult;
83488 }
83489
83490
83491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
83492   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83493
83494   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83495   {
83496     try {
83497       delete arg1;
83498     } catch (std::out_of_range& e) {
83499       {
83500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83501       };
83502     } catch (std::exception& e) {
83503       {
83504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83505       };
83506     } catch (...) {
83507       {
83508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83509       };
83510     }
83511   }
83512 }
83513
83514
83515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
83516   unsigned int jresult ;
83517   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83518   bool result;
83519
83520   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83521   {
83522     try {
83523       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83524     } catch (std::out_of_range& e) {
83525       {
83526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83527       };
83528     } catch (std::exception& e) {
83529       {
83530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83531       };
83532     } catch (...) {
83533       {
83534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83535       };
83536     }
83537   }
83538   jresult = result;
83539   return jresult;
83540 }
83541
83542
83543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
83544   unsigned long jresult ;
83545   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83546   std::size_t result;
83547
83548   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83549   {
83550     try {
83551       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83552     } catch (std::out_of_range& e) {
83553       {
83554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83555       };
83556     } catch (std::exception& e) {
83557       {
83558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83559       };
83560     } catch (...) {
83561       {
83562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83563       };
83564     }
83565   }
83566   jresult = (unsigned long)result;
83567   return jresult;
83568 }
83569
83570
83571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
83572   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83573   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83574
83575   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83576   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83577   {
83578     try {
83579       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
83580     } catch (std::out_of_range& e) {
83581       {
83582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83583       };
83584     } catch (std::exception& e) {
83585       {
83586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83587       };
83588     } catch (...) {
83589       {
83590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83591       };
83592     }
83593   }
83594 }
83595
83596
83597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
83598   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83599   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83600
83601   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83602   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83603   {
83604     try {
83605       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
83606     } catch (std::out_of_range& e) {
83607       {
83608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83609       };
83610     } catch (std::exception& e) {
83611       {
83612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83613       };
83614     } catch (...) {
83615       {
83616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83617       };
83618     }
83619   }
83620 }
83621
83622
83623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
83624   unsigned int jresult ;
83625   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83626   Dali::Toolkit::Button arg2 ;
83627   Dali::Toolkit::Button *argp2 ;
83628   bool result;
83629
83630   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83631   argp2 = (Dali::Toolkit::Button *)jarg2;
83632   if (!argp2) {
83633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
83634     return 0;
83635   }
83636   arg2 = *argp2;
83637   {
83638     try {
83639       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
83640     } catch (std::out_of_range& e) {
83641       {
83642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83643       };
83644     } catch (std::exception& e) {
83645       {
83646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83647       };
83648     } catch (...) {
83649       {
83650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83651       };
83652     }
83653   }
83654   jresult = result;
83655   return jresult;
83656 }
83657
83658
83659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
83660   void * jresult ;
83661   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
83662
83663   {
83664     try {
83665       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
83666     } catch (std::out_of_range& e) {
83667       {
83668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83669       };
83670     } catch (std::exception& e) {
83671       {
83672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83673       };
83674     } catch (...) {
83675       {
83676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83677       };
83678     }
83679   }
83680   jresult = (void *)result;
83681   return jresult;
83682 }
83683
83684
83685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
83686   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83687
83688   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83689   {
83690     try {
83691       delete arg1;
83692     } catch (std::out_of_range& e) {
83693       {
83694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83695       };
83696     } catch (std::exception& e) {
83697       {
83698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83699       };
83700     } catch (...) {
83701       {
83702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83703       };
83704     }
83705   }
83706 }
83707
83708
83709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
83710   unsigned int jresult ;
83711   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83712   bool result;
83713
83714   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83715   {
83716     try {
83717       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83718     } catch (std::out_of_range& e) {
83719       {
83720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83721       };
83722     } catch (std::exception& e) {
83723       {
83724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83725       };
83726     } catch (...) {
83727       {
83728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83729       };
83730     }
83731   }
83732   jresult = result;
83733   return jresult;
83734 }
83735
83736
83737 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
83738   unsigned long jresult ;
83739   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83740   std::size_t result;
83741
83742   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83743   {
83744     try {
83745       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83746     } catch (std::out_of_range& e) {
83747       {
83748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83749       };
83750     } catch (std::exception& e) {
83751       {
83752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83753       };
83754     } catch (...) {
83755       {
83756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83757       };
83758     }
83759   }
83760   jresult = (unsigned long)result;
83761   return jresult;
83762 }
83763
83764
83765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
83766   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83767   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83768
83769   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83770   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83771   {
83772     try {
83773       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
83774     } catch (std::out_of_range& e) {
83775       {
83776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83777       };
83778     } catch (std::exception& e) {
83779       {
83780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83781       };
83782     } catch (...) {
83783       {
83784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83785       };
83786     }
83787   }
83788 }
83789
83790
83791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
83792   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83793   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83794
83795   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83796   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83797   {
83798     try {
83799       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
83800     } catch (std::out_of_range& e) {
83801       {
83802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83803       };
83804     } catch (std::exception& e) {
83805       {
83806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83807       };
83808     } catch (...) {
83809       {
83810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83811       };
83812     }
83813   }
83814 }
83815
83816
83817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
83818   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83819   Dali::Toolkit::GaussianBlurView arg2 ;
83820   Dali::Toolkit::GaussianBlurView *argp2 ;
83821
83822   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83823   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83824   if (!argp2) {
83825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
83826     return ;
83827   }
83828   arg2 = *argp2;
83829   {
83830     try {
83831       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
83832     } catch (std::out_of_range& e) {
83833       {
83834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83835       };
83836     } catch (std::exception& e) {
83837       {
83838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83839       };
83840     } catch (...) {
83841       {
83842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83843       };
83844     }
83845   }
83846 }
83847
83848
83849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
83850   void * jresult ;
83851   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
83852
83853   {
83854     try {
83855       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
83856     } catch (std::out_of_range& e) {
83857       {
83858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83859       };
83860     } catch (std::exception& e) {
83861       {
83862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83863       };
83864     } catch (...) {
83865       {
83866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83867       };
83868     }
83869   }
83870   jresult = (void *)result;
83871   return jresult;
83872 }
83873
83874
83875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
83876   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83877
83878   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83879   {
83880     try {
83881       delete arg1;
83882     } catch (std::out_of_range& e) {
83883       {
83884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83885       };
83886     } catch (std::exception& e) {
83887       {
83888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83889       };
83890     } catch (...) {
83891       {
83892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83893       };
83894     }
83895   }
83896 }
83897
83898
83899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
83900   unsigned int jresult ;
83901   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83902   bool result;
83903
83904   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83905   {
83906     try {
83907       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);
83908     } catch (std::out_of_range& e) {
83909       {
83910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83911       };
83912     } catch (std::exception& e) {
83913       {
83914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83915       };
83916     } catch (...) {
83917       {
83918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83919       };
83920     }
83921   }
83922   jresult = result;
83923   return jresult;
83924 }
83925
83926
83927 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
83928   unsigned long jresult ;
83929   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83930   std::size_t result;
83931
83932   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83933   {
83934     try {
83935       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);
83936     } catch (std::out_of_range& e) {
83937       {
83938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83939       };
83940     } catch (std::exception& e) {
83941       {
83942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83943       };
83944     } catch (...) {
83945       {
83946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83947       };
83948     }
83949   }
83950   jresult = (unsigned long)result;
83951   return jresult;
83952 }
83953
83954
83955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
83956   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83957   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83958
83959   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83960   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83961   {
83962     try {
83963       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
83964     } catch (std::out_of_range& e) {
83965       {
83966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83967       };
83968     } catch (std::exception& e) {
83969       {
83970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83971       };
83972     } catch (...) {
83973       {
83974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83975       };
83976     }
83977   }
83978 }
83979
83980
83981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
83982   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
83983   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
83984
83985   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
83986   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
83987   {
83988     try {
83989       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83990     } catch (std::out_of_range& e) {
83991       {
83992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83993       };
83994     } catch (std::exception& e) {
83995       {
83996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83997       };
83998     } catch (...) {
83999       {
84000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84001       };
84002     }
84003   }
84004 }
84005
84006
84007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
84008   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84009   Dali::Toolkit::PageTurnView arg2 ;
84010   unsigned int arg3 ;
84011   bool arg4 ;
84012   Dali::Toolkit::PageTurnView *argp2 ;
84013
84014   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84015   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84016   if (!argp2) {
84017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84018     return ;
84019   }
84020   arg2 = *argp2;
84021   arg3 = (unsigned int)jarg3;
84022   arg4 = jarg4 ? true : false;
84023   {
84024     try {
84025       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84026     } catch (std::out_of_range& e) {
84027       {
84028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84029       };
84030     } catch (std::exception& e) {
84031       {
84032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84033       };
84034     } catch (...) {
84035       {
84036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84037       };
84038     }
84039   }
84040 }
84041
84042
84043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
84044   void * jresult ;
84045   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
84046
84047   {
84048     try {
84049       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
84050     } catch (std::out_of_range& e) {
84051       {
84052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84053       };
84054     } catch (std::exception& e) {
84055       {
84056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84057       };
84058     } catch (...) {
84059       {
84060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84061       };
84062     }
84063   }
84064   jresult = (void *)result;
84065   return jresult;
84066 }
84067
84068
84069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
84070   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84071
84072   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84073   {
84074     try {
84075       delete arg1;
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 int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
84094   unsigned int jresult ;
84095   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84096   bool result;
84097
84098   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84099   {
84100     try {
84101       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
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 = result;
84117   return jresult;
84118 }
84119
84120
84121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
84122   unsigned long jresult ;
84123   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84124   std::size_t result;
84125
84126   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84127   {
84128     try {
84129       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
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_PagePanSignal_Connect(void * jarg1, void * jarg2) {
84150   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84151   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84152
84153   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84154   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84155   {
84156     try {
84157       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,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_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
84176   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84177   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84178
84179   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84180   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84181   {
84182     try {
84183       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
84184     } catch (std::out_of_range& e) {
84185       {
84186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84187       };
84188     } catch (std::exception& e) {
84189       {
84190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84191       };
84192     } catch (...) {
84193       {
84194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84195       };
84196     }
84197   }
84198 }
84199
84200
84201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
84202   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84203   Dali::Toolkit::PageTurnView arg2 ;
84204   Dali::Toolkit::PageTurnView *argp2 ;
84205
84206   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84207   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84208   if (!argp2) {
84209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84210     return ;
84211   }
84212   arg2 = *argp2;
84213   {
84214     try {
84215       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
84216     } catch (std::out_of_range& e) {
84217       {
84218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84219       };
84220     } catch (std::exception& e) {
84221       {
84222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84223       };
84224     } catch (...) {
84225       {
84226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84227       };
84228     }
84229   }
84230 }
84231
84232
84233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
84234   void * jresult ;
84235   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
84236
84237   {
84238     try {
84239       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
84240     } catch (std::out_of_range& e) {
84241       {
84242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84243       };
84244     } catch (std::exception& e) {
84245       {
84246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84247       };
84248     } catch (...) {
84249       {
84250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84251       };
84252     }
84253   }
84254   jresult = (void *)result;
84255   return jresult;
84256 }
84257
84258
84259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
84260   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84261
84262   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84263   {
84264     try {
84265       delete arg1;
84266     } catch (std::out_of_range& e) {
84267       {
84268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84269       };
84270     } catch (std::exception& e) {
84271       {
84272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84273       };
84274     } catch (...) {
84275       {
84276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84277       };
84278     }
84279   }
84280 }
84281
84282
84283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
84284   unsigned int jresult ;
84285   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84286   bool result;
84287
84288   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84289   {
84290     try {
84291       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);
84292     } catch (std::out_of_range& e) {
84293       {
84294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84295       };
84296     } catch (std::exception& e) {
84297       {
84298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84299       };
84300     } catch (...) {
84301       {
84302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84303       };
84304     }
84305   }
84306   jresult = result;
84307   return jresult;
84308 }
84309
84310
84311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
84312   unsigned long jresult ;
84313   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84314   std::size_t result;
84315
84316   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84317   {
84318     try {
84319       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);
84320     } catch (std::out_of_range& e) {
84321       {
84322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84323       };
84324     } catch (std::exception& e) {
84325       {
84326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84327       };
84328     } catch (...) {
84329       {
84330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84331       };
84332     }
84333   }
84334   jresult = (unsigned long)result;
84335   return jresult;
84336 }
84337
84338
84339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
84340   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84341   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84342
84343   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84344   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84345   {
84346     try {
84347       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
84348     } catch (std::out_of_range& e) {
84349       {
84350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84351       };
84352     } catch (std::exception& e) {
84353       {
84354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84355       };
84356     } catch (...) {
84357       {
84358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84359       };
84360     }
84361   }
84362 }
84363
84364
84365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
84366   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84367   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84368
84369   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84370   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84371   {
84372     try {
84373       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
84374     } catch (std::out_of_range& e) {
84375       {
84376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84377       };
84378     } catch (std::exception& e) {
84379       {
84380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84381       };
84382     } catch (...) {
84383       {
84384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84385       };
84386     }
84387   }
84388 }
84389
84390
84391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
84392   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84393   Dali::Toolkit::ProgressBar arg2 ;
84394   float arg3 ;
84395   float arg4 ;
84396   Dali::Toolkit::ProgressBar *argp2 ;
84397
84398   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84399   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
84400   if (!argp2) {
84401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
84402     return ;
84403   }
84404   arg2 = *argp2;
84405   arg3 = (float)jarg3;
84406   arg4 = (float)jarg4;
84407   {
84408     try {
84409       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84410     } catch (std::out_of_range& e) {
84411       {
84412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84413       };
84414     } catch (std::exception& e) {
84415       {
84416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84417       };
84418     } catch (...) {
84419       {
84420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84421       };
84422     }
84423   }
84424 }
84425
84426
84427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
84428   void * jresult ;
84429   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
84430
84431   {
84432     try {
84433       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
84434     } catch (std::out_of_range& e) {
84435       {
84436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84437       };
84438     } catch (std::exception& e) {
84439       {
84440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84441       };
84442     } catch (...) {
84443       {
84444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84445       };
84446     }
84447   }
84448   jresult = (void *)result;
84449   return jresult;
84450 }
84451
84452
84453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
84454   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84455
84456   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84457   {
84458     try {
84459       delete arg1;
84460     } catch (std::out_of_range& e) {
84461       {
84462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84463       };
84464     } catch (std::exception& e) {
84465       {
84466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84467       };
84468     } catch (...) {
84469       {
84470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84471       };
84472     }
84473   }
84474 }
84475
84476
84477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
84478   unsigned int jresult ;
84479   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84480   bool result;
84481
84482   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84483   {
84484     try {
84485       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);
84486     } catch (std::out_of_range& e) {
84487       {
84488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84489       };
84490     } catch (std::exception& e) {
84491       {
84492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84493       };
84494     } catch (...) {
84495       {
84496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84497       };
84498     }
84499   }
84500   jresult = result;
84501   return jresult;
84502 }
84503
84504
84505 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
84506   unsigned long jresult ;
84507   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84508   std::size_t result;
84509
84510   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84511   {
84512     try {
84513       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);
84514     } catch (std::out_of_range& e) {
84515       {
84516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84517       };
84518     } catch (std::exception& e) {
84519       {
84520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84521       };
84522     } catch (...) {
84523       {
84524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84525       };
84526     }
84527   }
84528   jresult = (unsigned long)result;
84529   return jresult;
84530 }
84531
84532
84533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
84534   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84535   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84536
84537   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84538   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84539   {
84540     try {
84541       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84542     } catch (std::out_of_range& e) {
84543       {
84544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84545       };
84546     } catch (std::exception& e) {
84547       {
84548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84549       };
84550     } catch (...) {
84551       {
84552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84553       };
84554     }
84555   }
84556 }
84557
84558
84559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
84560   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84561   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84562
84563   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84564   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84565   {
84566     try {
84567       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84568     } catch (std::out_of_range& e) {
84569       {
84570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84571       };
84572     } catch (std::exception& e) {
84573       {
84574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84575       };
84576     } catch (...) {
84577       {
84578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84579       };
84580     }
84581   }
84582 }
84583
84584
84585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
84586   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84587   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
84588
84589   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84590   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
84591   if (!arg2) {
84592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
84593     return ;
84594   }
84595   {
84596     try {
84597       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
84598     } catch (std::out_of_range& e) {
84599       {
84600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84601       };
84602     } catch (std::exception& e) {
84603       {
84604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84605       };
84606     } catch (...) {
84607       {
84608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84609       };
84610     }
84611   }
84612 }
84613
84614
84615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
84616   void * jresult ;
84617   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
84618
84619   {
84620     try {
84621       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
84622     } catch (std::out_of_range& e) {
84623       {
84624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84625       };
84626     } catch (std::exception& e) {
84627       {
84628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84629       };
84630     } catch (...) {
84631       {
84632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84633       };
84634     }
84635   }
84636   jresult = (void *)result;
84637   return jresult;
84638 }
84639
84640
84641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
84642   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84643
84644   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84645   {
84646     try {
84647       delete arg1;
84648     } catch (std::out_of_range& e) {
84649       {
84650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84651       };
84652     } catch (std::exception& e) {
84653       {
84654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84655       };
84656     } catch (...) {
84657       {
84658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84659       };
84660     }
84661   }
84662 }
84663
84664
84665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
84666   unsigned int jresult ;
84667   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84668   bool result;
84669
84670   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84671   {
84672     try {
84673       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84674     } catch (std::out_of_range& e) {
84675       {
84676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84677       };
84678     } catch (std::exception& e) {
84679       {
84680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84681       };
84682     } catch (...) {
84683       {
84684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84685       };
84686     }
84687   }
84688   jresult = result;
84689   return jresult;
84690 }
84691
84692
84693 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
84694   unsigned long jresult ;
84695   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84696   std::size_t result;
84697
84698   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84699   {
84700     try {
84701       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84702     } catch (std::out_of_range& e) {
84703       {
84704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84705       };
84706     } catch (std::exception& e) {
84707       {
84708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84709       };
84710     } catch (...) {
84711       {
84712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84713       };
84714     }
84715   }
84716   jresult = (unsigned long)result;
84717   return jresult;
84718 }
84719
84720
84721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
84722   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84723   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84724
84725   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84726   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84727   {
84728     try {
84729       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
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_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
84748   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84749   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84750
84751   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84752   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84753   {
84754     try {
84755       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84756     } catch (std::out_of_range& e) {
84757       {
84758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84759       };
84760     } catch (std::exception& e) {
84761       {
84762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84763       };
84764     } catch (...) {
84765       {
84766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84767       };
84768     }
84769   }
84770 }
84771
84772
84773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
84774   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84775   Dali::Vector2 *arg2 = 0 ;
84776
84777   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84778   arg2 = (Dali::Vector2 *)jarg2;
84779   if (!arg2) {
84780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84781     return ;
84782   }
84783   {
84784     try {
84785       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
84786     } catch (std::out_of_range& e) {
84787       {
84788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84789       };
84790     } catch (std::exception& e) {
84791       {
84792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84793       };
84794     } catch (...) {
84795       {
84796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84797       };
84798     }
84799   }
84800 }
84801
84802
84803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
84804   void * jresult ;
84805   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
84806
84807   {
84808     try {
84809       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
84810     } catch (std::out_of_range& e) {
84811       {
84812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84813       };
84814     } catch (std::exception& e) {
84815       {
84816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84817       };
84818     } catch (...) {
84819       {
84820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84821       };
84822     }
84823   }
84824   jresult = (void *)result;
84825   return jresult;
84826 }
84827
84828
84829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
84830   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84831
84832   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84833   {
84834     try {
84835       delete arg1;
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
84854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
84855   unsigned int jresult ;
84856   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84857   bool result;
84858
84859   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84860   {
84861     try {
84862       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);
84863     } catch (std::out_of_range& e) {
84864       {
84865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84866       };
84867     } catch (std::exception& e) {
84868       {
84869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84870       };
84871     } catch (...) {
84872       {
84873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84874       };
84875     }
84876   }
84877   jresult = result;
84878   return jresult;
84879 }
84880
84881
84882 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
84883   unsigned long jresult ;
84884   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84885   std::size_t result;
84886
84887   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84888   {
84889     try {
84890       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);
84891     } catch (std::out_of_range& e) {
84892       {
84893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84894       };
84895     } catch (std::exception& e) {
84896       {
84897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84898       };
84899     } catch (...) {
84900       {
84901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84902       };
84903     }
84904   }
84905   jresult = (unsigned long)result;
84906   return jresult;
84907 }
84908
84909
84910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
84911   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84912   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84913
84914   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84915   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84916   {
84917     try {
84918       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84919     } catch (std::out_of_range& e) {
84920       {
84921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84922       };
84923     } catch (std::exception& e) {
84924       {
84925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84926       };
84927     } catch (...) {
84928       {
84929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84930       };
84931     }
84932   }
84933 }
84934
84935
84936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
84937   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84938   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
84939
84940   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84941   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
84942   {
84943     try {
84944       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84945     } catch (std::out_of_range& e) {
84946       {
84947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84948       };
84949     } catch (std::exception& e) {
84950       {
84951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84952       };
84953     } catch (...) {
84954       {
84955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84956       };
84957     }
84958   }
84959 }
84960
84961
84962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
84963   unsigned int jresult ;
84964   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
84965   Dali::Toolkit::Control arg2 ;
84966   Dali::KeyEvent *arg3 = 0 ;
84967   Dali::Toolkit::Control *argp2 ;
84968   bool result;
84969
84970   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
84971   argp2 = (Dali::Toolkit::Control *)jarg2;
84972   if (!argp2) {
84973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
84974     return 0;
84975   }
84976   arg2 = *argp2;
84977   arg3 = (Dali::KeyEvent *)jarg3;
84978   if (!arg3) {
84979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
84980     return 0;
84981   }
84982   {
84983     try {
84984       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);
84985     } catch (std::out_of_range& e) {
84986       {
84987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84988       };
84989     } catch (std::exception& e) {
84990       {
84991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84992       };
84993     } catch (...) {
84994       {
84995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84996       };
84997     }
84998   }
84999   jresult = result;
85000   return jresult;
85001 }
85002
85003
85004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
85005   void * jresult ;
85006   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
85007
85008   {
85009     try {
85010       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
85011     } catch (std::out_of_range& e) {
85012       {
85013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85014       };
85015     } catch (std::exception& e) {
85016       {
85017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85018       };
85019     } catch (...) {
85020       {
85021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85022       };
85023     }
85024   }
85025   jresult = (void *)result;
85026   return jresult;
85027 }
85028
85029
85030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
85031   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85032
85033   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85034   {
85035     try {
85036       delete arg1;
85037     } catch (std::out_of_range& e) {
85038       {
85039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85040       };
85041     } catch (std::exception& e) {
85042       {
85043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85044       };
85045     } catch (...) {
85046       {
85047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85048       };
85049     }
85050   }
85051 }
85052
85053
85054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
85055   unsigned int jresult ;
85056   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85057   bool result;
85058
85059   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85060   {
85061     try {
85062       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85063     } catch (std::out_of_range& e) {
85064       {
85065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85066       };
85067     } catch (std::exception& e) {
85068       {
85069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85070       };
85071     } catch (...) {
85072       {
85073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85074       };
85075     }
85076   }
85077   jresult = result;
85078   return jresult;
85079 }
85080
85081
85082 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
85083   unsigned long jresult ;
85084   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85085   std::size_t result;
85086
85087   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85088   {
85089     try {
85090       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85091     } catch (std::out_of_range& e) {
85092       {
85093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85094       };
85095     } catch (std::exception& e) {
85096       {
85097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85098       };
85099     } catch (...) {
85100       {
85101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85102       };
85103     }
85104   }
85105   jresult = (unsigned long)result;
85106   return jresult;
85107 }
85108
85109
85110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
85111   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85112   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85113
85114   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85115   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85116   {
85117     try {
85118       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
85119     } catch (std::out_of_range& e) {
85120       {
85121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85122       };
85123     } catch (std::exception& e) {
85124       {
85125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85126       };
85127     } catch (...) {
85128       {
85129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85130       };
85131     }
85132   }
85133 }
85134
85135
85136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
85137   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85138   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85139
85140   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85141   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85142   {
85143     try {
85144       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
85145     } catch (std::out_of_range& e) {
85146       {
85147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85148       };
85149     } catch (std::exception& e) {
85150       {
85151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85152       };
85153     } catch (...) {
85154       {
85155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85156       };
85157     }
85158   }
85159 }
85160
85161
85162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
85163   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85164   Dali::Toolkit::Control arg2 ;
85165   Dali::Toolkit::Control *argp2 ;
85166
85167   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85168   argp2 = (Dali::Toolkit::Control *)jarg2;
85169   if (!argp2) {
85170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85171     return ;
85172   }
85173   arg2 = *argp2;
85174   {
85175     try {
85176       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
85177     } catch (std::out_of_range& e) {
85178       {
85179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85180       };
85181     } catch (std::exception& e) {
85182       {
85183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85184       };
85185     } catch (...) {
85186       {
85187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85188       };
85189     }
85190   }
85191 }
85192
85193
85194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
85195   void * jresult ;
85196   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
85197
85198   {
85199     try {
85200       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
85201     } catch (std::out_of_range& e) {
85202       {
85203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85204       };
85205     } catch (std::exception& e) {
85206       {
85207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85208       };
85209     } catch (...) {
85210       {
85211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85212       };
85213     }
85214   }
85215   jresult = (void *)result;
85216   return jresult;
85217 }
85218
85219
85220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
85221   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85222
85223   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85224   {
85225     try {
85226       delete arg1;
85227     } catch (std::out_of_range& e) {
85228       {
85229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85230       };
85231     } catch (std::exception& e) {
85232       {
85233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85234       };
85235     } catch (...) {
85236       {
85237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85238       };
85239     }
85240   }
85241 }
85242
85243
85244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
85245   unsigned int jresult ;
85246   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85247   bool result;
85248
85249   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85250   {
85251     try {
85252       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85253     } catch (std::out_of_range& e) {
85254       {
85255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85256       };
85257     } catch (std::exception& e) {
85258       {
85259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85260       };
85261     } catch (...) {
85262       {
85263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85264       };
85265     }
85266   }
85267   jresult = result;
85268   return jresult;
85269 }
85270
85271
85272 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
85273   unsigned long jresult ;
85274   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85275   std::size_t result;
85276
85277   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85278   {
85279     try {
85280       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85281     } catch (std::out_of_range& e) {
85282       {
85283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85284       };
85285     } catch (std::exception& e) {
85286       {
85287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85288       };
85289     } catch (...) {
85290       {
85291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85292       };
85293     }
85294   }
85295   jresult = (unsigned long)result;
85296   return jresult;
85297 }
85298
85299
85300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
85301   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85302   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85303
85304   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85305   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85306   {
85307     try {
85308       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
85309     } catch (std::out_of_range& e) {
85310       {
85311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85312       };
85313     } catch (std::exception& e) {
85314       {
85315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85316       };
85317     } catch (...) {
85318       {
85319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85320       };
85321     }
85322   }
85323 }
85324
85325
85326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
85327   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85328   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85329
85330   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85331   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85332   {
85333     try {
85334       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
85335     } catch (std::out_of_range& e) {
85336       {
85337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85338       };
85339     } catch (std::exception& e) {
85340       {
85341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85342       };
85343     } catch (...) {
85344       {
85345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85346       };
85347     }
85348   }
85349 }
85350
85351
85352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
85353   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85354   Dali::Toolkit::VideoView *arg2 = 0 ;
85355
85356   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85357   arg2 = (Dali::Toolkit::VideoView *)jarg2;
85358   if (!arg2) {
85359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
85360     return ;
85361   }
85362   {
85363     try {
85364       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
85365     } catch (std::out_of_range& e) {
85366       {
85367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85368       };
85369     } catch (std::exception& e) {
85370       {
85371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85372       };
85373     } catch (...) {
85374       {
85375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85376       };
85377     }
85378   }
85379 }
85380
85381
85382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
85383   void * jresult ;
85384   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
85385
85386   {
85387     try {
85388       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
85389     } catch (std::out_of_range& e) {
85390       {
85391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85392       };
85393     } catch (std::exception& e) {
85394       {
85395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85396       };
85397     } catch (...) {
85398       {
85399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85400       };
85401     }
85402   }
85403   jresult = (void *)result;
85404   return jresult;
85405 }
85406
85407
85408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
85409   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85410
85411   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85412   {
85413     try {
85414       delete arg1;
85415     } catch (std::out_of_range& e) {
85416       {
85417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85418       };
85419     } catch (std::exception& e) {
85420       {
85421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85422       };
85423     } catch (...) {
85424       {
85425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85426       };
85427     }
85428   }
85429 }
85430
85431
85432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
85433   unsigned int jresult ;
85434   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85435   bool result;
85436
85437   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85438   {
85439     try {
85440       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85441     } catch (std::out_of_range& e) {
85442       {
85443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85444       };
85445     } catch (std::exception& e) {
85446       {
85447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85448       };
85449     } catch (...) {
85450       {
85451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85452       };
85453     }
85454   }
85455   jresult = result;
85456   return jresult;
85457 }
85458
85459
85460 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
85461   unsigned long jresult ;
85462   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85463   std::size_t result;
85464
85465   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85466   {
85467     try {
85468       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85469     } catch (std::out_of_range& e) {
85470       {
85471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85472       };
85473     } catch (std::exception& e) {
85474       {
85475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85476       };
85477     } catch (...) {
85478       {
85479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85480       };
85481     }
85482   }
85483   jresult = (unsigned long)result;
85484   return jresult;
85485 }
85486
85487
85488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
85489   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85490   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85491
85492   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85493   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85494   {
85495     try {
85496       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
85497     } catch (std::out_of_range& e) {
85498       {
85499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85500       };
85501     } catch (std::exception& e) {
85502       {
85503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85504       };
85505     } catch (...) {
85506       {
85507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85508       };
85509     }
85510   }
85511 }
85512
85513
85514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85515   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85516   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85517
85518   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85519   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85520   {
85521     try {
85522       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
85523     } catch (std::out_of_range& e) {
85524       {
85525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85526       };
85527     } catch (std::exception& e) {
85528       {
85529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85530       };
85531     } catch (...) {
85532       {
85533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85534       };
85535     }
85536   }
85537 }
85538
85539
85540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
85541   unsigned int jresult ;
85542   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85543   Dali::Toolkit::Slider arg2 ;
85544   float arg3 ;
85545   Dali::Toolkit::Slider *argp2 ;
85546   bool result;
85547
85548   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85549   argp2 = (Dali::Toolkit::Slider *)jarg2;
85550   if (!argp2) {
85551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85552     return 0;
85553   }
85554   arg2 = *argp2;
85555   arg3 = (float)jarg3;
85556   {
85557     try {
85558       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
85559     } catch (std::out_of_range& e) {
85560       {
85561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85562       };
85563     } catch (std::exception& e) {
85564       {
85565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85566       };
85567     } catch (...) {
85568       {
85569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85570       };
85571     }
85572   }
85573   jresult = result;
85574   return jresult;
85575 }
85576
85577
85578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
85579   void * jresult ;
85580   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
85581
85582   {
85583     try {
85584       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
85585     } catch (std::out_of_range& e) {
85586       {
85587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85588       };
85589     } catch (std::exception& e) {
85590       {
85591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85592       };
85593     } catch (...) {
85594       {
85595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85596       };
85597     }
85598   }
85599   jresult = (void *)result;
85600   return jresult;
85601 }
85602
85603
85604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
85605   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85606
85607   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85608   {
85609     try {
85610       delete arg1;
85611     } catch (std::out_of_range& e) {
85612       {
85613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85614       };
85615     } catch (std::exception& e) {
85616       {
85617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85618       };
85619     } catch (...) {
85620       {
85621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85622       };
85623     }
85624   }
85625 }
85626
85627
85628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
85629   unsigned int jresult ;
85630   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85631   bool result;
85632
85633   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85634   {
85635     try {
85636       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85637     } catch (std::out_of_range& e) {
85638       {
85639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85640       };
85641     } catch (std::exception& e) {
85642       {
85643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85644       };
85645     } catch (...) {
85646       {
85647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85648       };
85649     }
85650   }
85651   jresult = result;
85652   return jresult;
85653 }
85654
85655
85656 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
85657   unsigned long jresult ;
85658   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85659   std::size_t result;
85660
85661   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85662   {
85663     try {
85664       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85665     } catch (std::out_of_range& e) {
85666       {
85667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85668       };
85669     } catch (std::exception& e) {
85670       {
85671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85672       };
85673     } catch (...) {
85674       {
85675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85676       };
85677     }
85678   }
85679   jresult = (unsigned long)result;
85680   return jresult;
85681 }
85682
85683
85684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
85685   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85686   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85687
85688   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85689   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85690   {
85691     try {
85692       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
85693     } catch (std::out_of_range& e) {
85694       {
85695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85696       };
85697     } catch (std::exception& e) {
85698       {
85699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85700       };
85701     } catch (...) {
85702       {
85703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85704       };
85705     }
85706   }
85707 }
85708
85709
85710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
85711   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85712   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85713
85714   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85715   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85716   {
85717     try {
85718       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
85719     } catch (std::out_of_range& e) {
85720       {
85721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85722       };
85723     } catch (std::exception& e) {
85724       {
85725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85726       };
85727     } catch (...) {
85728       {
85729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85730       };
85731     }
85732   }
85733 }
85734
85735
85736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85737   unsigned int jresult ;
85738   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85739   Dali::Toolkit::Slider arg2 ;
85740   int arg3 ;
85741   Dali::Toolkit::Slider *argp2 ;
85742   bool result;
85743
85744   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85745   argp2 = (Dali::Toolkit::Slider *)jarg2;
85746   if (!argp2) {
85747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85748     return 0;
85749   }
85750   arg2 = *argp2;
85751   arg3 = (int)jarg3;
85752   {
85753     try {
85754       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
85755     } catch (std::out_of_range& e) {
85756       {
85757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85758       };
85759     } catch (std::exception& e) {
85760       {
85761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85762       };
85763     } catch (...) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85766       };
85767     }
85768   }
85769   jresult = result;
85770   return jresult;
85771 }
85772
85773
85774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
85775   void * jresult ;
85776   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
85777
85778   {
85779     try {
85780       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
85781     } catch (std::out_of_range& e) {
85782       {
85783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85784       };
85785     } catch (std::exception& e) {
85786       {
85787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85788       };
85789     } catch (...) {
85790       {
85791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85792       };
85793     }
85794   }
85795   jresult = (void *)result;
85796   return jresult;
85797 }
85798
85799
85800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
85801   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85802
85803   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85804   {
85805     try {
85806       delete arg1;
85807     } catch (std::out_of_range& e) {
85808       {
85809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85810       };
85811     } catch (std::exception& e) {
85812       {
85813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85814       };
85815     } catch (...) {
85816       {
85817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85818       };
85819     }
85820   }
85821 }
85822
85823
85824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
85825   void * jresult ;
85826   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85827
85828   {
85829     try {
85830       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
85831     } catch (std::out_of_range& e) {
85832       {
85833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85834       };
85835     } catch (std::exception& e) {
85836       {
85837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85838       };
85839     } catch (...) {
85840       {
85841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85842       };
85843     }
85844   }
85845   jresult = (void *)result;
85846   return jresult;
85847 }
85848
85849
85850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
85851   void * jresult ;
85852   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
85853   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85854
85855   arg1 = (Dali::Toolkit::Ruler *)jarg1;
85856   {
85857     try {
85858       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
85859     } catch (std::out_of_range& e) {
85860       {
85861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85862       };
85863     } catch (std::exception& e) {
85864       {
85865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85866       };
85867     } catch (...) {
85868       {
85869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85870       };
85871     }
85872   }
85873   jresult = (void *)result;
85874   return jresult;
85875 }
85876
85877
85878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
85879   void * jresult ;
85880   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
85881   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85882
85883   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85884   if (!arg1) {
85885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
85886     return 0;
85887   }
85888   {
85889     try {
85890       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
85891     } catch (std::out_of_range& e) {
85892       {
85893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85894       };
85895     } catch (std::exception& e) {
85896       {
85897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85898       };
85899     } catch (...) {
85900       {
85901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85902       };
85903     }
85904   }
85905   jresult = (void *)result;
85906   return jresult;
85907 }
85908
85909
85910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
85911   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85912
85913   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85914   {
85915     try {
85916       delete arg1;
85917     } catch (std::out_of_range& e) {
85918       {
85919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85920       };
85921     } catch (std::exception& e) {
85922       {
85923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85924       };
85925     } catch (...) {
85926       {
85927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85928       };
85929     }
85930   }
85931 }
85932
85933
85934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
85935   void * jresult ;
85936   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85937   Dali::Toolkit::Ruler *result = 0 ;
85938
85939   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85940   {
85941     try {
85942       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
85943     } catch (std::out_of_range& e) {
85944       {
85945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85946       };
85947     } catch (std::exception& e) {
85948       {
85949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85950       };
85951     } catch (...) {
85952       {
85953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85954       };
85955     }
85956   }
85957   jresult = (void *)result;
85958   return jresult;
85959 }
85960
85961
85962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
85963   void * jresult ;
85964   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85965   Dali::Toolkit::Ruler *result = 0 ;
85966
85967   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85968   {
85969     try {
85970       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
85971     } catch (std::out_of_range& e) {
85972       {
85973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85974       };
85975     } catch (std::exception& e) {
85976       {
85977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85978       };
85979     } catch (...) {
85980       {
85981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85982       };
85983     }
85984   }
85985   jresult = (void *)result;
85986   return jresult;
85987 }
85988
85989
85990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
85991   void * jresult ;
85992   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
85993   Dali::Toolkit::Ruler *result = 0 ;
85994
85995   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
85996   {
85997     try {
85998       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
85999     } catch (std::out_of_range& e) {
86000       {
86001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86002       };
86003     } catch (std::exception& e) {
86004       {
86005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86006       };
86007     } catch (...) {
86008       {
86009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86010       };
86011     }
86012   }
86013   jresult = (void *)result;
86014   return jresult;
86015 }
86016
86017
86018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
86019   void * jresult ;
86020   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86021   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
86022   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86023
86024   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86025   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
86026   if (!arg2) {
86027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
86028     return 0;
86029   }
86030   {
86031     try {
86032       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
86033     } catch (std::out_of_range& e) {
86034       {
86035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86036       };
86037     } catch (std::exception& e) {
86038       {
86039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86040       };
86041     } catch (...) {
86042       {
86043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86044       };
86045     }
86046   }
86047   jresult = (void *)result;
86048   return jresult;
86049 }
86050
86051
86052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
86053   void * jresult ;
86054   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86055   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86056   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86057
86058   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86059   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86060   {
86061     try {
86062       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
86063     } catch (std::out_of_range& e) {
86064       {
86065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86066       };
86067     } catch (std::exception& e) {
86068       {
86069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86070       };
86071     } catch (...) {
86072       {
86073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86074       };
86075     }
86076   }
86077   jresult = (void *)result;
86078   return jresult;
86079 }
86080
86081
86082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
86083   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86084
86085   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86086   {
86087     try {
86088       (arg1)->Reset();
86089     } catch (std::out_of_range& e) {
86090       {
86091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86092       };
86093     } catch (std::exception& e) {
86094       {
86095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86096       };
86097     } catch (...) {
86098       {
86099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86100       };
86101     }
86102   }
86103 }
86104
86105
86106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
86107   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86108   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86109
86110   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86111   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86112   {
86113     try {
86114       (arg1)->Reset(arg2);
86115     } catch (std::out_of_range& e) {
86116       {
86117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86118       };
86119     } catch (std::exception& e) {
86120       {
86121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86122       };
86123     } catch (...) {
86124       {
86125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86126       };
86127     }
86128   }
86129 }
86130
86131
86132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
86133   void * jresult ;
86134   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86135   Dali::Toolkit::Ruler *result = 0 ;
86136
86137   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86138   {
86139     try {
86140       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
86141     } catch (std::out_of_range& e) {
86142       {
86143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86144       };
86145     } catch (std::exception& e) {
86146       {
86147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86148       };
86149     } catch (...) {
86150       {
86151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86152       };
86153     }
86154   }
86155   jresult = (void *)result;
86156   return jresult;
86157 }
86158
86159
86160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
86161   float jresult ;
86162   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86163   float arg2 ;
86164   float arg3 ;
86165   float result;
86166
86167   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86168   arg2 = (float)jarg2;
86169   arg3 = (float)jarg3;
86170   {
86171     try {
86172       result = (float)(*arg1)->Snap(arg2,arg3);
86173     } catch (std::out_of_range& e) {
86174       {
86175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86176       };
86177     } catch (std::exception& e) {
86178       {
86179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86180       };
86181     } catch (...) {
86182       {
86183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86184       };
86185     }
86186   }
86187   jresult = result;
86188   return jresult;
86189 }
86190
86191
86192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
86193   float jresult ;
86194   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86195   float arg2 ;
86196   float result;
86197
86198   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86199   arg2 = (float)jarg2;
86200   {
86201     try {
86202       result = (float)(*arg1)->Snap(arg2);
86203     } catch (std::out_of_range& e) {
86204       {
86205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86206       };
86207     } catch (std::exception& e) {
86208       {
86209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86210       };
86211     } catch (...) {
86212       {
86213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86214       };
86215     }
86216   }
86217   jresult = result;
86218   return jresult;
86219 }
86220
86221
86222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
86223   float jresult ;
86224   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86225   unsigned int arg2 ;
86226   unsigned int *arg3 = 0 ;
86227   bool arg4 ;
86228   float result;
86229
86230   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86231   arg2 = (unsigned int)jarg2;
86232   arg3 = (unsigned int *)jarg3;
86233   arg4 = jarg4 ? true : false;
86234   {
86235     try {
86236       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
86237     } catch (std::out_of_range& e) {
86238       {
86239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86240       };
86241     } catch (std::exception& e) {
86242       {
86243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86244       };
86245     } catch (...) {
86246       {
86247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86248       };
86249     }
86250   }
86251   jresult = result;
86252   return jresult;
86253 }
86254
86255
86256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
86257   unsigned int jresult ;
86258   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86259   float arg2 ;
86260   bool arg3 ;
86261   unsigned int result;
86262
86263   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86264   arg2 = (float)jarg2;
86265   arg3 = jarg3 ? true : false;
86266   {
86267     try {
86268       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
86269     } catch (std::out_of_range& e) {
86270       {
86271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86272       };
86273     } catch (std::exception& e) {
86274       {
86275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86276       };
86277     } catch (...) {
86278       {
86279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86280       };
86281     }
86282   }
86283   jresult = result;
86284   return jresult;
86285 }
86286
86287
86288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
86289   unsigned int jresult ;
86290   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86291   unsigned int result;
86292
86293   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86294   {
86295     try {
86296       result = (unsigned int)(*arg1)->GetTotalPages();
86297     } catch (std::out_of_range& e) {
86298       {
86299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86300       };
86301     } catch (std::exception& e) {
86302       {
86303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86304       };
86305     } catch (...) {
86306       {
86307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86308       };
86309     }
86310   }
86311   jresult = result;
86312   return jresult;
86313 }
86314
86315
86316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
86317   int jresult ;
86318   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86319   Dali::Toolkit::Ruler::RulerType result;
86320
86321   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86322   {
86323     try {
86324       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
86325     } catch (std::out_of_range& e) {
86326       {
86327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86328       };
86329     } catch (std::exception& e) {
86330       {
86331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86332       };
86333     } catch (...) {
86334       {
86335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86336       };
86337     }
86338   }
86339   jresult = (int)result;
86340   return jresult;
86341 }
86342
86343
86344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
86345   unsigned int jresult ;
86346   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86347   bool result;
86348
86349   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86350   {
86351     try {
86352       result = (bool)(*arg1)->IsEnabled();
86353     } catch (std::out_of_range& e) {
86354       {
86355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86356       };
86357     } catch (std::exception& e) {
86358       {
86359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86360       };
86361     } catch (...) {
86362       {
86363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86364       };
86365     }
86366   }
86367   jresult = result;
86368   return jresult;
86369 }
86370
86371
86372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
86373   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86374
86375   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86376   {
86377     try {
86378       (*arg1)->Enable();
86379     } catch (std::out_of_range& e) {
86380       {
86381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86382       };
86383     } catch (std::exception& e) {
86384       {
86385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86386       };
86387     } catch (...) {
86388       {
86389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86390       };
86391     }
86392   }
86393 }
86394
86395
86396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
86397   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86398
86399   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86400   {
86401     try {
86402       (*arg1)->Disable();
86403     } catch (std::out_of_range& e) {
86404       {
86405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86406       };
86407     } catch (std::exception& e) {
86408       {
86409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86410       };
86411     } catch (...) {
86412       {
86413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86414       };
86415     }
86416   }
86417 }
86418
86419
86420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
86421   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86422   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
86423   Dali::Toolkit::RulerDomain *argp2 ;
86424
86425   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86426   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
86427   if (!argp2) {
86428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
86429     return ;
86430   }
86431   arg2 = *argp2;
86432   {
86433     try {
86434       (*arg1)->SetDomain(arg2);
86435     } catch (std::out_of_range& e) {
86436       {
86437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86438       };
86439     } catch (std::exception& e) {
86440       {
86441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86442       };
86443     } catch (...) {
86444       {
86445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86446       };
86447     }
86448   }
86449 }
86450
86451
86452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
86453   void * jresult ;
86454   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86455   Dali::Toolkit::RulerDomain *result = 0 ;
86456
86457   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86458   {
86459     try {
86460       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
86461     } catch (std::out_of_range& e) {
86462       {
86463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86464       };
86465     } catch (std::exception& e) {
86466       {
86467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86468       };
86469     } catch (...) {
86470       {
86471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86472       };
86473     }
86474   }
86475   jresult = (void *)result;
86476   return jresult;
86477 }
86478
86479
86480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
86481   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86482
86483   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86484   {
86485     try {
86486       (*arg1)->DisableDomain();
86487     } catch (std::out_of_range& e) {
86488       {
86489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86490       };
86491     } catch (std::exception& e) {
86492       {
86493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86494       };
86495     } catch (...) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86498       };
86499     }
86500   }
86501 }
86502
86503
86504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
86505   float jresult ;
86506   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86507   float arg2 ;
86508   float arg3 ;
86509   float arg4 ;
86510   float result;
86511
86512   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86513   arg2 = (float)jarg2;
86514   arg3 = (float)jarg3;
86515   arg4 = (float)jarg4;
86516   {
86517     try {
86518       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
86519     } catch (std::out_of_range& e) {
86520       {
86521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86522       };
86523     } catch (std::exception& e) {
86524       {
86525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86526       };
86527     } catch (...) {
86528       {
86529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86530       };
86531     }
86532   }
86533   jresult = result;
86534   return jresult;
86535 }
86536
86537
86538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
86539   float jresult ;
86540   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86541   float arg2 ;
86542   float arg3 ;
86543   float result;
86544
86545   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86546   arg2 = (float)jarg2;
86547   arg3 = (float)jarg3;
86548   {
86549     try {
86550       result = (float)(*arg1)->Clamp(arg2,arg3);
86551     } catch (std::out_of_range& e) {
86552       {
86553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86554       };
86555     } catch (std::exception& e) {
86556       {
86557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86558       };
86559     } catch (...) {
86560       {
86561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86562       };
86563     }
86564   }
86565   jresult = result;
86566   return jresult;
86567 }
86568
86569
86570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
86571   float jresult ;
86572   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86573   float arg2 ;
86574   float result;
86575
86576   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86577   arg2 = (float)jarg2;
86578   {
86579     try {
86580       result = (float)(*arg1)->Clamp(arg2);
86581     } catch (std::out_of_range& e) {
86582       {
86583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86584       };
86585     } catch (std::exception& e) {
86586       {
86587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86588       };
86589     } catch (...) {
86590       {
86591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86592       };
86593     }
86594   }
86595   jresult = result;
86596   return jresult;
86597 }
86598
86599
86600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
86601   float jresult ;
86602   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86603   float arg2 ;
86604   float arg3 ;
86605   float arg4 ;
86606   Dali::Toolkit::ClampState *arg5 = 0 ;
86607   float result;
86608
86609   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86610   arg2 = (float)jarg2;
86611   arg3 = (float)jarg3;
86612   arg4 = (float)jarg4;
86613   arg5 = (Dali::Toolkit::ClampState *)jarg5;
86614   if (!arg5) {
86615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86616     return 0;
86617   }
86618   {
86619     try {
86620       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
86621     } catch (std::out_of_range& e) {
86622       {
86623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86624       };
86625     } catch (std::exception& e) {
86626       {
86627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86628       };
86629     } catch (...) {
86630       {
86631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86632       };
86633     }
86634   }
86635   jresult = result;
86636   return jresult;
86637 }
86638
86639
86640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
86641   float jresult ;
86642   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86643   float arg2 ;
86644   float arg3 ;
86645   float arg4 ;
86646   float arg5 ;
86647   float result;
86648
86649   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86650   arg2 = (float)jarg2;
86651   arg3 = (float)jarg3;
86652   arg4 = (float)jarg4;
86653   arg5 = (float)jarg5;
86654   {
86655     try {
86656       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
86657     } catch (std::out_of_range& e) {
86658       {
86659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86660       };
86661     } catch (std::exception& e) {
86662       {
86663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86664       };
86665     } catch (...) {
86666       {
86667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86668       };
86669     }
86670   }
86671   jresult = result;
86672   return jresult;
86673 }
86674
86675
86676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
86677   float jresult ;
86678   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86679   float arg2 ;
86680   float arg3 ;
86681   float arg4 ;
86682   float result;
86683
86684   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86685   arg2 = (float)jarg2;
86686   arg3 = (float)jarg3;
86687   arg4 = (float)jarg4;
86688   {
86689     try {
86690       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
86691     } catch (std::out_of_range& e) {
86692       {
86693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86694       };
86695     } catch (std::exception& e) {
86696       {
86697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86698       };
86699     } catch (...) {
86700       {
86701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86702       };
86703     }
86704   }
86705   jresult = result;
86706   return jresult;
86707 }
86708
86709
86710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
86711   float jresult ;
86712   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86713   float arg2 ;
86714   float arg3 ;
86715   float result;
86716
86717   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86718   arg2 = (float)jarg2;
86719   arg3 = (float)jarg3;
86720   {
86721     try {
86722       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
86723     } catch (std::out_of_range& e) {
86724       {
86725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86726       };
86727     } catch (std::exception& e) {
86728       {
86729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86730       };
86731     } catch (...) {
86732       {
86733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86734       };
86735     }
86736   }
86737   jresult = result;
86738   return jresult;
86739 }
86740
86741
86742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
86743   float jresult ;
86744   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86745   float arg2 ;
86746   float result;
86747
86748   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86749   arg2 = (float)jarg2;
86750   {
86751     try {
86752       result = (float)(*arg1)->SnapAndClamp(arg2);
86753     } catch (std::out_of_range& e) {
86754       {
86755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86756       };
86757     } catch (std::exception& e) {
86758       {
86759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86760       };
86761     } catch (...) {
86762       {
86763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86764       };
86765     }
86766   }
86767   jresult = result;
86768   return jresult;
86769 }
86770
86771
86772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
86773   float jresult ;
86774   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86775   float arg2 ;
86776   float arg3 ;
86777   float arg4 ;
86778   float arg5 ;
86779   Dali::Toolkit::ClampState *arg6 = 0 ;
86780   float result;
86781
86782   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86783   arg2 = (float)jarg2;
86784   arg3 = (float)jarg3;
86785   arg4 = (float)jarg4;
86786   arg5 = (float)jarg5;
86787   arg6 = (Dali::Toolkit::ClampState *)jarg6;
86788   if (!arg6) {
86789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86790     return 0;
86791   }
86792   {
86793     try {
86794       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
86795     } catch (std::out_of_range& e) {
86796       {
86797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86798       };
86799     } catch (std::exception& e) {
86800       {
86801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86802       };
86803     } catch (...) {
86804       {
86805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86806       };
86807     }
86808   }
86809   jresult = result;
86810   return jresult;
86811 }
86812
86813
86814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
86815   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86816
86817   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86818   {
86819     try {
86820       (*arg1)->Reference();
86821     } catch (std::out_of_range& e) {
86822       {
86823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86824       };
86825     } catch (std::exception& e) {
86826       {
86827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86828       };
86829     } catch (...) {
86830       {
86831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86832       };
86833     }
86834   }
86835 }
86836
86837
86838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
86839   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86840
86841   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86842   {
86843     try {
86844       (*arg1)->Unreference();
86845     } catch (std::out_of_range& e) {
86846       {
86847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86848       };
86849     } catch (std::exception& e) {
86850       {
86851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86852       };
86853     } catch (...) {
86854       {
86855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86856       };
86857     }
86858   }
86859 }
86860
86861
86862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
86863   int jresult ;
86864   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86865   int result;
86866
86867   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86868   {
86869     try {
86870       result = (int)(*arg1)->ReferenceCount();
86871     } catch (std::out_of_range& e) {
86872       {
86873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86874       };
86875     } catch (std::exception& e) {
86876       {
86877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86878       };
86879     } catch (...) {
86880       {
86881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86882       };
86883     }
86884   }
86885   jresult = result;
86886   return jresult;
86887 }
86888
86889
86890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
86891   unsigned int jresult ;
86892   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86893   bool result;
86894
86895   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86896   {
86897     try {
86898       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86899     } catch (std::out_of_range& e) {
86900       {
86901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86902       };
86903     } catch (std::exception& e) {
86904       {
86905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86906       };
86907     } catch (...) {
86908       {
86909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86910       };
86911     }
86912   }
86913   jresult = result;
86914   return jresult;
86915 }
86916
86917
86918 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
86919   unsigned long jresult ;
86920   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86921   std::size_t result;
86922
86923   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86924   {
86925     try {
86926       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
86927     } catch (std::out_of_range& e) {
86928       {
86929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86930       };
86931     } catch (std::exception& e) {
86932       {
86933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86934       };
86935     } catch (...) {
86936       {
86937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86938       };
86939     }
86940   }
86941   jresult = (unsigned long)result;
86942   return jresult;
86943 }
86944
86945
86946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
86947   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86948   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86949
86950   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86951   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86952   {
86953     try {
86954       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
86955     } catch (std::out_of_range& e) {
86956       {
86957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86958       };
86959     } catch (std::exception& e) {
86960       {
86961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86962       };
86963     } catch (...) {
86964       {
86965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86966       };
86967     }
86968   }
86969 }
86970
86971
86972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
86973   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
86974   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
86975
86976   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
86977   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
86978   {
86979     try {
86980       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
86981     } catch (std::out_of_range& e) {
86982       {
86983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86984       };
86985     } catch (std::exception& e) {
86986       {
86987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86988       };
86989     } catch (...) {
86990       {
86991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86992       };
86993     }
86994   }
86995 }
86996
86997
86998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
86999   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87000   Dali::Toolkit::Control arg2 ;
87001   Dali::Toolkit::Control *argp2 ;
87002
87003   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87004   argp2 = (Dali::Toolkit::Control *)jarg2;
87005   if (!argp2) {
87006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87007     return ;
87008   }
87009   arg2 = *argp2;
87010   {
87011     try {
87012       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
87013     } catch (std::out_of_range& e) {
87014       {
87015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87016       };
87017     } catch (std::exception& e) {
87018       {
87019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87020       };
87021     } catch (...) {
87022       {
87023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87024       };
87025     }
87026   }
87027 }
87028
87029
87030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
87031   void * jresult ;
87032   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87033
87034   {
87035     try {
87036       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87037     } catch (std::out_of_range& e) {
87038       {
87039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87040       };
87041     } catch (std::exception& e) {
87042       {
87043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87044       };
87045     } catch (...) {
87046       {
87047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87048       };
87049     }
87050   }
87051   jresult = (void *)result;
87052   return jresult;
87053 }
87054
87055
87056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
87057   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87058
87059   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87060   {
87061     try {
87062       delete arg1;
87063     } catch (std::out_of_range& e) {
87064       {
87065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87066       };
87067     } catch (std::exception& e) {
87068       {
87069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87070       };
87071     } catch (...) {
87072       {
87073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87074       };
87075     }
87076   }
87077 }
87078
87079 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
87080   Dali::RefObject *result = NULL;
87081
87082   if (arg1)
87083   {
87084     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
87085   }
87086   return result;
87087 }
87088
87089 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
87090     return (Dali::RefObject *)jarg1;
87091 }
87092
87093 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
87094     return (Dali::SignalObserver *)jarg1;
87095 }
87096
87097 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
87098     return (Dali::ConnectionTrackerInterface *)jarg1;
87099 }
87100
87101 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
87102     return (Dali::BaseHandle *)jarg1;
87103 }
87104
87105 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
87106     return (Dali::BaseHandle *)jarg1;
87107 }
87108
87109 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
87110     return (Dali::BaseHandle *)jarg1;
87111 }
87112
87113 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
87114     return (Dali::BaseHandle *)jarg1;
87115 }
87116
87117 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
87118     return (Dali::BaseHandle *)jarg1;
87119 }
87120
87121 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
87122     return (Dali::BaseHandle *)jarg1;
87123 }
87124
87125 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
87126     return (Dali::BaseHandle *)jarg1;
87127 }
87128
87129 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
87130     return (Dali::BaseHandle *)jarg1;
87131 }
87132
87133 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
87134     return (Dali::BaseHandle *)jarg1;
87135 }
87136
87137 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
87138     return (Dali::BaseHandle *)jarg1;
87139 }
87140
87141 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
87142     return (Dali::BaseHandle *)jarg1;
87143 }
87144
87145 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
87146     return (Dali::BaseHandle *)jarg1;
87147 }
87148
87149 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
87150     return (Dali::BaseHandle *)jarg1;
87151 }
87152
87153 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
87154     return (Dali::Handle *)jarg1;
87155 }
87156
87157 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
87158     return (Dali::Handle *)jarg1;
87159 }
87160
87161 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
87162     return (Dali::BaseHandle *)jarg1;
87163 }
87164
87165 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
87166     return (Dali::BaseHandle *)jarg1;
87167 }
87168
87169 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
87170     return (Dali::Handle *)jarg1;
87171 }
87172
87173 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
87174     return (Dali::BaseHandle *)jarg1;
87175 }
87176
87177 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
87178     return (Dali::Handle *)jarg1;
87179 }
87180
87181 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
87182     return (Dali::GestureDetector *)jarg1;
87183 }
87184
87185 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
87186     return (Dali::Gesture *)jarg1;
87187 }
87188
87189 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
87190     return (Dali::Handle *)jarg1;
87191 }
87192
87193 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
87194     return (Dali::Actor *)jarg1;
87195 }
87196
87197 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
87198     return (Dali::BaseHandle *)jarg1;
87199 }
87200
87201 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
87202     return (Dali::RefObject *)jarg1;
87203 }
87204
87205 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
87206     return (Dali::Actor *)jarg1;
87207 }
87208
87209 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
87210     return (Dali::GestureDetector *)jarg1;
87211 }
87212
87213 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
87214     return (Dali::Gesture *)jarg1;
87215 }
87216
87217 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
87218     return (Dali::GestureDetector *)jarg1;
87219 }
87220
87221 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
87222     return (Dali::Gesture *)jarg1;
87223 }
87224
87225 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
87226     return (Dali::GestureDetector *)jarg1;
87227 }
87228
87229 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
87230     return (Dali::Gesture *)jarg1;
87231 }
87232
87233 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
87234     return (Dali::BaseHandle *)jarg1;
87235 }
87236
87237 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
87238     return (Dali::Handle *)jarg1;
87239 }
87240
87241 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
87242     return (Dali::Handle *)jarg1;
87243 }
87244
87245 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
87246     return (Dali::Handle *)jarg1;
87247 }
87248
87249 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
87250     return (Dali::Image *)jarg1;
87251 }
87252
87253 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
87254     return (Dali::Image *)jarg1;
87255 }
87256
87257 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
87258     return (Dali::Image *)jarg1;
87259 }
87260
87261 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
87262     return (Dali::RefObject *)jarg1;
87263 }
87264
87265 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
87266     return (Dali::Image *)jarg1;
87267 }
87268
87269 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
87270     return (Dali::Image *)jarg1;
87271 }
87272
87273 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
87274     return (Dali::ResourceImage *)jarg1;
87275 }
87276
87277 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
87278     return (Dali::Actor *)jarg1;
87279 }
87280
87281 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
87282     return (Dali::BaseHandle *)jarg1;
87283 }
87284
87285 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
87286     return (Dali::BaseHandle *)jarg1;
87287 }
87288
87289
87290 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
87291     return (Dali::BaseHandle *)jarg1;
87292 }
87293
87294 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
87295     return (Dali::BaseHandle *)jarg1;
87296 }
87297
87298 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
87299     return (Dali::CustomActorImpl *)jarg1;
87300 }
87301
87302 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
87303     return (Dali::CustomActor *)jarg1;
87304 }
87305
87306 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
87307     return (Dali::BaseHandle *)jarg1;
87308 }
87309
87310 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
87311     return (Dali::Toolkit::Control *)jarg1;
87312 }
87313
87314 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
87315     return (Dali::Toolkit::Control *)jarg1;
87316 }
87317
87318 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
87319     return (Dali::Toolkit::Button *)jarg1;
87320 }
87321
87322 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
87323     return (Dali::Toolkit::Button *)jarg1;
87324 }
87325
87326 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
87327     return (Dali::Toolkit::Button *)jarg1;
87328 }
87329
87330 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
87331     return (Dali::Toolkit::Control *)jarg1;
87332 }
87333
87334 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
87335     return (Dali::Toolkit::Control *)jarg1;
87336 }
87337
87338 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
87339     return (Dali::Toolkit::Control *)jarg1;
87340 }
87341
87342 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
87343     return (Dali::Toolkit::Control *)jarg1;
87344 }
87345
87346 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
87347     return (Dali::Toolkit::Control *)jarg1;
87348 }
87349
87350 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
87351     return (Dali::RefObject *)jarg1;
87352 }
87353
87354 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
87355     return (Dali::Toolkit::Scrollable *)jarg1;
87356 }
87357
87358 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
87359     return (Dali::BaseHandle *)jarg1;
87360 }
87361
87362 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
87363     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
87364 }
87365
87366 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
87367     return (Dali::RefObject *)jarg1;
87368 }
87369
87370 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
87371     return (Dali::Toolkit::Ruler *)jarg1;
87372 }
87373
87374 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
87375     return (Dali::Toolkit::Ruler *)jarg1;
87376 }
87377
87378 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
87379     return (Dali::Toolkit::Scrollable *)jarg1;
87380 }
87381
87382 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
87383     return (Dali::Toolkit::Control *)jarg1;
87384 }
87385
87386
87387 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
87388     return (Dali::Toolkit::Control *)jarg1;
87389 }
87390
87391 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
87392     return (Dali::BaseHandle *)jarg1;
87393 }
87394
87395 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
87396     return (Dali::BaseHandle *)jarg1;
87397 }
87398
87399 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
87400     return (Dali::Toolkit::Control *)jarg1;
87401 }
87402
87403 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
87404     return (Dali::Toolkit::Control *)jarg1;
87405 }
87406
87407 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
87408     return (Dali::Toolkit::Control *)jarg1;
87409 }
87410
87411 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
87412     return (Dali::Toolkit::Control *)jarg1;
87413 }
87414
87415 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
87416     return (Dali::Toolkit::Control *)jarg1;
87417 }
87418
87419 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
87420     return (Dali::Toolkit::Control *)jarg1;
87421 }
87422
87423 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
87424     return (Dali::Toolkit::PageTurnView *)jarg1;
87425 }
87426
87427 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
87428     return (Dali::Toolkit::PageTurnView *)jarg1;
87429 }
87430
87431 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
87432     return (Dali::Toolkit::Button *)jarg1;
87433 }
87434
87435 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
87436     return (Dali::BaseHandle *)jarg1;
87437 }
87438
87439 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
87440     return (Dali::BaseHandle *)jarg1;
87441 }
87442
87443 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
87444     return (Dali::BaseHandle *)jarg1;
87445 }
87446
87447
87448 #ifdef __cplusplus
87449 }
87450 #endif