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 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 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 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 #include <dali/devel-api/common/stage-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467
 468 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 469
 470 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 471 #include <dali/devel-api/adaptor-framework/image-loading.h>
 472
 473 #include <dali/public-api/events/mouse-button.h>
 474
 475 // add here SWIG version check
 476
 477 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 478 // disable Swig-dependent warnings
 479
 480 // 'identifier1' has C-linkage specified,
 481 // but returns UDT 'identifier2' which is incompatible with C
 482 #pragma warning(disable: 4190)
 483
 484 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 485 #pragma warning(disable: 4800)
 486
 487 // debug info too long etc etc
 488 #pragma warning(disable: 4786)
 489 #endif
 490
 491
 492 #include <stdexcept>
 493
 494
 495 #include <string>
 496
 497
 498 #include <vector>
 499 #include <algorithm>
 500 #include <stdexcept>
 501
 502
 503 #include <map>
 504 #include <algorithm>
 505 #include <stdexcept>
 506
 507
 508 #include <utility>
 509
 510
 511 typedef float floatp;
 512
 513 SWIGINTERN floatp *new_floatp(){
 514   return new float();
 515 }
 516 SWIGINTERN void delete_floatp(floatp *self){
 517   if (self) delete self;
 518 }
 519 SWIGINTERN void floatp_assign(floatp *self,float value){
 520   *self = value;
 521 }
 522 SWIGINTERN float floatp_value(floatp *self){
 523   return *self;
 524 }
 525 SWIGINTERN float *floatp_cast(floatp *self){
 526   return self;
 527 }
 528 SWIGINTERN floatp *floatp_frompointer(float *t){
 529   return (floatp *) t;
 530 }
 531
 532 typedef int intp;
 533
 534 SWIGINTERN intp *new_intp(){
 535   return new int();
 536 }
 537 SWIGINTERN void delete_intp(intp *self){
 538   if (self) delete self;
 539 }
 540 SWIGINTERN void intp_assign(intp *self,int value){
 541   *self = value;
 542 }
 543 SWIGINTERN int intp_value(intp *self){
 544   return *self;
 545 }
 546 SWIGINTERN int *intp_cast(intp *self){
 547   return self;
 548 }
 549 SWIGINTERN intp *intp_frompointer(int *t){
 550   return (intp *) t;
 551 }
 552
 553 typedef double doublep;
 554
 555 SWIGINTERN doublep *new_doublep(){
 556   return new double();
 557 }
 558 SWIGINTERN void delete_doublep(doublep *self){
 559   if (self) delete self;
 560 }
 561 SWIGINTERN void doublep_assign(doublep *self,double value){
 562   *self = value;
 563 }
 564 SWIGINTERN double doublep_value(doublep *self){
 565   return *self;
 566 }
 567 SWIGINTERN double *doublep_cast(doublep *self){
 568   return self;
 569 }
 570 SWIGINTERN doublep *doublep_frompointer(double *t){
 571   return (doublep *) t;
 572 }
 573
 574 typedef unsigned int uintp;
 575
 576 SWIGINTERN uintp *new_uintp(){
 577   return new unsigned int();
 578 }
 579 SWIGINTERN void delete_uintp(uintp *self){
 580   if (self) delete self;
 581 }
 582 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 583   *self = value;
 584 }
 585 SWIGINTERN unsigned int uintp_value(uintp *self){
 586   return *self;
 587 }
 588 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 589   return self;
 590 }
 591 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 592   return (uintp *) t;
 593 }
 594
 595 typedef unsigned short ushortp;
 596
 597 SWIGINTERN ushortp *new_ushortp(){
 598   return new unsigned short();
 599 }
 600 SWIGINTERN void delete_ushortp(ushortp *self){
 601   if (self) delete self;
 602 }
 603 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 604   *self = value;
 605 }
 606 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 607   return *self;
 608 }
 609 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 610   return self;
 611 }
 612 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 613   return (ushortp *) t;
 614 }
 615
 616 unsigned int int_to_uint(int x) {
 617    return (unsigned int) x;
 618 }
 619
 620
 621 using namespace Dali;
 622 using namespace Dali::Toolkit;
 623
 624 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 625 {
 626   bool result = false;
 627   try
 628   {
 629     // C++ code. DALi uses Handle <-> Body design pattern.
 630     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 631     // Handles in DALi can be converted into a boolean type
 632     // to check if the handle has a valid body attached to it.
 633     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 634     if( *self )
 635     {
 636       result = true;
 637     }
 638     else
 639     {
 640       result = false;
 641     }
 642   }
 643   catch (std::out_of_range& e)
 644   {
 645     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 646     return 0;
 647   }
 648   catch (std::exception& e)
 649   {
 650     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 651     return 0;
 652   }
 653   catch (DaliException e)
 654   {
 655     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 656     return 0;
 657   }
 658   catch (...)
 659   {
 660     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 661     return 0;
 662   }
 663   return result;
 664 }
 665
 666 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 667 {
 668   bool result = false;
 669   try
 670   {
 671     // C++ code. Check if two handles reference the same implemtion
 672     if( *self == rhs)
 673     {
 674       result = true;
 675     }
 676     else
 677     {
 678       result = false;
 679     }
 680   }
 681   catch (std::out_of_range& e)
 682   {
 683     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 684     return 0;
 685   }
 686   catch (std::exception& e)
 687   {
 688     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 689     return 0;
 690   }
 691   catch (DaliException e)
 692   {
 693     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 694     return 0;
 695   }
 696   catch (...)
 697   {
 698     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 699     return 0;
 700   }
 701   return result;
 702 }
 703
 704
 705 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 706      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 707    }
 708 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){
 709      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 710    }
 711 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 712         std::vector< Dali::TouchPoint >* pv = 0;
 713         if (capacity >= 0) {
 714           pv = new std::vector< Dali::TouchPoint >();
 715           pv->reserve(capacity);
 716        } else {
 717           throw std::out_of_range("capacity");
 718        }
 719        return pv;
 720       }
 721 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 722         if (index>=0 && index<(int)self->size())
 723           return (*self)[index];
 724         else
 725           throw std::out_of_range("index");
 726       }
 727 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 728         if (index>=0 && index<(int)self->size())
 729           return (*self)[index];
 730         else
 731           throw std::out_of_range("index");
 732       }
 733 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 734         if (index>=0 && index<(int)self->size())
 735           (*self)[index] = val;
 736         else
 737           throw std::out_of_range("index");
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 740         self->insert(self->end(), values.begin(), values.end());
 741       }
 742 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 743         if (index < 0)
 744           throw std::out_of_range("index");
 745         if (count < 0)
 746           throw std::out_of_range("count");
 747         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 748           throw std::invalid_argument("invalid range");
 749         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 750       }
 751 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 752         if (index>=0 && index<(int)self->size()+1)
 753           self->insert(self->begin()+index, x);
 754         else
 755           throw std::out_of_range("index");
 756       }
 757 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 758         if (index>=0 && index<(int)self->size()+1)
 759           self->insert(self->begin()+index, values.begin(), values.end());
 760         else
 761           throw std::out_of_range("index");
 762       }
 763 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 764         if (index>=0 && index<(int)self->size())
 765           self->erase(self->begin() + index);
 766         else
 767           throw std::out_of_range("index");
 768       }
 769 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 770         if (index < 0)
 771           throw std::out_of_range("index");
 772         if (count < 0)
 773           throw std::out_of_range("count");
 774         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 775           throw std::invalid_argument("invalid range");
 776         self->erase(self->begin()+index, self->begin()+index+count);
 777       }
 778 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 779         if (count < 0)
 780           throw std::out_of_range("count");
 781         return new std::vector< Dali::TouchPoint >(count, value);
 782       }
 783 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 784         std::reverse(self->begin(), self->end());
 785       }
 786 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 787         if (index < 0)
 788           throw std::out_of_range("index");
 789         if (count < 0)
 790           throw std::out_of_range("count");
 791         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 792           throw std::invalid_argument("invalid range");
 793         std::reverse(self->begin()+index, self->begin()+index+count);
 794       }
 795 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 796         if (index < 0)
 797           throw std::out_of_range("index");
 798         if (index+values.size() > self->size())
 799           throw std::out_of_range("index");
 800         std::copy(values.begin(), values.end(), self->begin()+index);
 801       }
 802 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 803          return self->Empty();
 804       }
 805 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 806         return self->GetConnectionCount();
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 809           self->Connect( func );
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 812           self->Disconnect( func );
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 815           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 816 /*@SWIG@*/ self->Emit( arg );
 817       }
 818 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 819          return self->Empty();
 820       }
 821 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 822         return self->GetConnectionCount();
 823       }
 824 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 825           self->Connect( func );
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 828           self->Disconnect( func );
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 831           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 832 /*@SWIG@*/ self->Emit( arg );
 833       }
 834 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 835          return self->Empty();
 836       }
 837 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){
 838         return self->GetConnectionCount();
 839       }
 840 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 *)){
 841           self->Connect( func );
 842       }
 843 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 *)){
 844           self->Disconnect( func );
 845       }
 846 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){
 847           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 848 /*@SWIG@*/ self->Emit( arg );
 849       }
 850 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 851          return self->Empty();
 852       }
 853 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 854         return self->GetConnectionCount();
 855       }
 856 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 857           self->Connect( func );
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 860           self->Disconnect( func );
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 863           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 864 /*@SWIG@*/ self->Emit( arg );
 865       }
 866 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 867          return self->Empty();
 868       }
 869 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 870         return self->GetConnectionCount();
 871       }
 872 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 873           self->Connect( func );
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 876           self->Disconnect( func );
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 879           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 880 /*@SWIG@*/ self->Emit( arg );
 881       }
 882 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){
 883          return self->Empty();
 884       }
 885 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){
 886         return self->GetConnectionCount();
 887       }
 888 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 &)){
 889         self->Connect( func );
 890       }
 891 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 &)){
 892         self->Disconnect( func );
 893       }
 894 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){
 895         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 896 /*@SWIG@*/ self->Emit( arg1, arg2 );
 897       }
 898 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){
 899          return self->Empty();
 900       }
 901 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){
 902         return self->GetConnectionCount();
 903       }
 904 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 &)){
 905         self->Connect( func );
 906       }
 907 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 &)){
 908         self->Disconnect( func );
 909       }
 910 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){
 911         return self->Emit( arg1, arg2 );
 912       }
 913 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){
 914          return self->Empty();
 915       }
 916 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){
 917         return self->GetConnectionCount();
 918       }
 919 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 &)){
 920         self->Connect( func );
 921       }
 922 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 &)){
 923         self->Disconnect( func );
 924       }
 925 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){
 926         return self->Emit( arg1, arg2 );
 927       }
 928 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){
 929          return self->Empty();
 930       }
 931 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){
 932         return self->GetConnectionCount();
 933       }
 934 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 &)){
 935         self->Connect( func );
 936       }
 937 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 &)){
 938         self->Disconnect( func );
 939       }
 940 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){
 941         return self->Emit( arg1, arg2 );
 942       }
 943 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 944          return self->Empty();
 945       }
 946 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 947         return self->GetConnectionCount();
 948       }
 949 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 950           self->Connect( func );
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 953           self->Disconnect( func );
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 956           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 957 /*@SWIG@*/ self->Emit( arg );
 958       }
 959 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 960          return self->Empty();
 961       }
 962 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){
 963         return self->GetConnectionCount();
 964       }
 965 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 &)){
 966           self->Connect( func );
 967       }
 968 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 &)){
 969           self->Disconnect( func );
 970       }
 971 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){
 972           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 973 /*@SWIG@*/ self->Emit( arg );
 974       }
 975 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 976          return self->Empty();
 977       }
 978 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){
 979         return self->GetConnectionCount();
 980       }
 981 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 &)){
 982           self->Connect( func );
 983       }
 984 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 &)){
 985           self->Disconnect( func );
 986       }
 987 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){
 988           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 989 /*@SWIG@*/ self->Emit( arg );
 990       }
 991 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 992          return self->Empty();
 993       }
 994 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){
 995         return self->GetConnectionCount();
 996       }
 997 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 &)){
 998           self->Connect( func );
 999       }
1000 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 &)){
1001           self->Disconnect( func );
1002       }
1003 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){
1004           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1005 /*@SWIG@*/ self->Emit( arg );
1006       }
1007 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){
1008          return self->Empty();
1009       }
1010 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){
1011         return self->GetConnectionCount();
1012       }
1013 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 &)){
1014         self->Connect( func );
1015       }
1016 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 &)){
1017         self->Disconnect( func );
1018       }
1019 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){
1020         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1021 /*@SWIG@*/ self->Emit( arg1, arg2 );
1022       }
1023 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){
1024          return self->Empty();
1025       }
1026 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){
1027         return self->GetConnectionCount();
1028       }
1029 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 &)){
1030         self->Connect( func );
1031       }
1032 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 &)){
1033         self->Disconnect( func );
1034       }
1035 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){
1036         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1037 /*@SWIG@*/ self->Emit( arg1, arg2 );
1038       }
1039 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){
1040          return self->Empty();
1041       }
1042 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){
1043         return self->GetConnectionCount();
1044       }
1045 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 &)){
1046         self->Connect( func );
1047       }
1048 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 &)){
1049         self->Disconnect( func );
1050       }
1051 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){
1052         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1053 /*@SWIG@*/ self->Emit( arg1, arg2 );
1054       }
1055 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1056          return self->Empty();
1057       }
1058 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1059         return self->GetConnectionCount();
1060       }
1061 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1062           self->Connect( func );
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1065           self->Disconnect( func );
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1068           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1069 /*@SWIG@*/ self->Emit( arg );
1070       }
1071 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1072          return self->Empty();
1073       }
1074 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1075         return self->GetConnectionCount();
1076       }
1077 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1078           return self->Connect( func );
1079       }
1080 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1081           self->Disconnect( func );
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1084           self->Emit( arg1, arg3 );
1085       }
1086 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){
1087          return self->Empty();
1088       }
1089 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){
1090         return self->GetConnectionCount();
1091       }
1092 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)){
1093           return self->Connect( func );
1094       }
1095 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)){
1096           self->Disconnect( func );
1097       }
1098 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){
1099           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1100 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1101       }
1102
1103 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1104          return self->Empty();
1105       }
1106 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1107         return self->GetConnectionCount();
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1110           self->Connect( func );
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1113           self->Disconnect( func );
1114       }
1115 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1116           return self->Emit();
1117       }
1118
1119 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1120         std::vector< unsigned int >* pv = 0;
1121         if (capacity >= 0) {
1122           pv = new std::vector< unsigned int >();
1123           pv->reserve(capacity);
1124        } else {
1125           throw std::out_of_range("capacity");
1126        }
1127        return pv;
1128       }
1129 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1130         if (index>=0 && index<(int)self->size())
1131           return (*self)[index];
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1142         if (index>=0 && index<(int)self->size())
1143           (*self)[index] = val;
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1148         self->insert(self->end(), values.begin(), values.end());
1149       }
1150 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1151         if (index < 0)
1152           throw std::out_of_range("index");
1153         if (count < 0)
1154           throw std::out_of_range("count");
1155         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1156           throw std::invalid_argument("invalid range");
1157         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1160         if (index>=0 && index<(int)self->size()+1)
1161           self->insert(self->begin()+index, x);
1162         else
1163           throw std::out_of_range("index");
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, values.begin(), values.end());
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1172         if (index>=0 && index<(int)self->size())
1173           self->erase(self->begin() + index);
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1178         if (index < 0)
1179           throw std::out_of_range("index");
1180         if (count < 0)
1181           throw std::out_of_range("count");
1182         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1183           throw std::invalid_argument("invalid range");
1184         self->erase(self->begin()+index, self->begin()+index+count);
1185       }
1186 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1187         if (count < 0)
1188           throw std::out_of_range("count");
1189         return new std::vector< unsigned int >(count, value);
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1192         std::reverse(self->begin(), self->end());
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1195         if (index < 0)
1196           throw std::out_of_range("index");
1197         if (count < 0)
1198           throw std::out_of_range("count");
1199         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1200           throw std::invalid_argument("invalid range");
1201         std::reverse(self->begin()+index, self->begin()+index+count);
1202       }
1203 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1204         if (index < 0)
1205           throw std::out_of_range("index");
1206         if (index+values.size() > self->size())
1207           throw std::out_of_range("index");
1208         std::copy(values.begin(), values.end(), self->begin()+index);
1209       }
1210 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1211         return std::find(self->begin(), self->end(), value) != self->end();
1212       }
1213 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1214         int index = -1;
1215         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1216         if (it != self->end())
1217           index = (int)(it - self->begin());
1218         return index;
1219       }
1220 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1221         int index = -1;
1222         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1223         if (rit != self->rend())
1224           index = (int)(self->rend() - 1 - rit);
1225         return index;
1226       }
1227 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1228         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1229         if (it != self->end()) {
1230           self->erase(it);
1231           return true;
1232         }
1233         return false;
1234       }
1235 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){
1236         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1237         if (capacity >= 0) {
1238           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1239           pv->reserve(capacity);
1240        } else {
1241           throw std::out_of_range("capacity");
1242        }
1243        return pv;
1244       }
1245 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){
1246         if (index>=0 && index<(int)self->size())
1247           return (*self)[index];
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 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){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 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){
1258         if (index>=0 && index<(int)self->size())
1259           (*self)[index] = val;
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 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){
1264         self->insert(self->end(), values.begin(), values.end());
1265       }
1266 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){
1267         if (index < 0)
1268           throw std::out_of_range("index");
1269         if (count < 0)
1270           throw std::out_of_range("count");
1271         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1272           throw std::invalid_argument("invalid range");
1273         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1274       }
1275 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){
1276         if (index>=0 && index<(int)self->size()+1)
1277           self->insert(self->begin()+index, x);
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 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){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, values.begin(), values.end());
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 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){
1288         if (index>=0 && index<(int)self->size())
1289           self->erase(self->begin() + index);
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 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){
1294         if (index < 0)
1295           throw std::out_of_range("index");
1296         if (count < 0)
1297           throw std::out_of_range("count");
1298         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1299           throw std::invalid_argument("invalid range");
1300         self->erase(self->begin()+index, self->begin()+index+count);
1301       }
1302 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){
1303         if (count < 0)
1304           throw std::out_of_range("count");
1305         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1306       }
1307 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){
1308         std::reverse(self->begin(), self->end());
1309       }
1310 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){
1311         if (index < 0)
1312           throw std::out_of_range("index");
1313         if (count < 0)
1314           throw std::out_of_range("count");
1315         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1316           throw std::invalid_argument("invalid range");
1317         std::reverse(self->begin()+index, self->begin()+index+count);
1318       }
1319 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){
1320         if (index < 0)
1321           throw std::out_of_range("index");
1322         if (index+values.size() > self->size())
1323           throw std::out_of_range("index");
1324         std::copy(values.begin(), values.end(), self->begin()+index);
1325       }
1326 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1327         std::vector< Dali::Actor >* pv = 0;
1328         if (capacity >= 0) {
1329           pv = new std::vector< Dali::Actor >();
1330           pv->reserve(capacity);
1331        } else {
1332           throw std::out_of_range("capacity");
1333        }
1334        return pv;
1335       }
1336 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1337         if (index>=0 && index<(int)self->size())
1338           return (*self)[index];
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1349         if (index>=0 && index<(int)self->size())
1350           (*self)[index] = val;
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1355         self->insert(self->end(), values.begin(), values.end());
1356       }
1357 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1358         if (index < 0)
1359           throw std::out_of_range("index");
1360         if (count < 0)
1361           throw std::out_of_range("count");
1362         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1363           throw std::invalid_argument("invalid range");
1364         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1367         if (index>=0 && index<(int)self->size()+1)
1368           self->insert(self->begin()+index, x);
1369         else
1370           throw std::out_of_range("index");
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, values.begin(), values.end());
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1379         if (index>=0 && index<(int)self->size())
1380           self->erase(self->begin() + index);
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1385         if (index < 0)
1386           throw std::out_of_range("index");
1387         if (count < 0)
1388           throw std::out_of_range("count");
1389         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1390           throw std::invalid_argument("invalid range");
1391         self->erase(self->begin()+index, self->begin()+index+count);
1392       }
1393 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1394         if (count < 0)
1395           throw std::out_of_range("count");
1396         return new std::vector< Dali::Actor >(count, value);
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1399         std::reverse(self->begin(), self->end());
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1402         if (index < 0)
1403           throw std::out_of_range("index");
1404         if (count < 0)
1405           throw std::out_of_range("count");
1406         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1407           throw std::invalid_argument("invalid range");
1408         std::reverse(self->begin()+index, self->begin()+index+count);
1409       }
1410 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1411         if (index < 0)
1412           throw std::out_of_range("index");
1413         if (index+values.size() > self->size())
1414           throw std::out_of_range("index");
1415         std::copy(values.begin(), values.end(), self->begin()+index);
1416       }
1417 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1418          return self->Empty();
1419       }
1420 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1421         return self->GetConnectionCount();
1422       }
1423 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 &)){
1424           self->Connect( func );
1425       }
1426 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 &)){
1427           self->Disconnect( func );
1428       }
1429 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){
1430           return self->Emit( arg );
1431       }
1432 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){
1433          return self->Empty();
1434       }
1435 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){
1436         return self->GetConnectionCount();
1437       }
1438 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)){
1439         self->Connect( func );
1440       }
1441 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)){
1442         self->Disconnect( func );
1443       }
1444 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){
1445         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1446 /*@SWIG@*/ self->Emit( arg1, arg2 );
1447       }
1448 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1449          return self->Empty();
1450       }
1451 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){
1452         return self->GetConnectionCount();
1453       }
1454 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)){
1455         self->Connect( func );
1456       }
1457 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)){
1458         self->Disconnect( func );
1459       }
1460 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){
1461         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1462 /*@SWIG@*/ self->Emit( arg1, arg2 );
1463       }
1464 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1465          return self->Empty();
1466       }
1467 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1468         return self->GetConnectionCount();
1469       }
1470 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)){
1471         self->Connect( func );
1472       }
1473 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)){
1474         self->Disconnect( func );
1475       }
1476 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){
1477         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1478 /*@SWIG@*/ self->Emit( arg1, arg2 );
1479       }
1480 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){
1481          return self->Empty();
1482       }
1483 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){
1484         return self->GetConnectionCount();
1485       }
1486 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)){
1487         self->Connect( func );
1488       }
1489 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)){
1490         self->Disconnect( func );
1491       }
1492 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){
1493         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1494 /*@SWIG@*/ self->Emit( arg1, arg2 );
1495       }
1496 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1497          return self->Empty();
1498       }
1499 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1500         return self->GetConnectionCount();
1501       }
1502 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)){
1503           self->Connect( func );
1504       }
1505 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)){
1506           self->Disconnect( func );
1507       }
1508 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1509           return self->Emit( arg );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1512          return self->Empty();
1513       }
1514 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1515         return self->GetConnectionCount();
1516       }
1517 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)){
1518           self->Connect( func );
1519       }
1520 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)){
1521           self->Disconnect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1524           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1525 /*@SWIG@*/ self->Emit( arg );
1526       }
1527 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){
1528          return self->Empty();
1529       }
1530 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){
1531         return self->GetConnectionCount();
1532       }
1533 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)){
1534           return self->Connect( func );
1535       }
1536 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)){
1537           self->Disconnect( func );
1538       }
1539 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){
1540           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1541 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1542       }
1543 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1544          return self->Empty();
1545       }
1546 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1547         return self->GetConnectionCount();
1548       }
1549 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)){
1550           self->Connect( func );
1551       }
1552 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)){
1553           self->Disconnect( func );
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1556           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1557 /*@SWIG@*/ self->Emit( arg );
1558       }
1559 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){
1560          return self->Empty();
1561       }
1562 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){
1563         return self->GetConnectionCount();
1564       }
1565 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)){
1566           return self->Connect( func );
1567       }
1568 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)){
1569           self->Disconnect( func );
1570       }
1571 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){
1572           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1573 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1574       }
1575 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){
1576          return self->Empty();
1577       }
1578 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){
1579         return self->GetConnectionCount();
1580       }
1581 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 &)){
1582           self->Connect( func );
1583       }
1584 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 &)){
1585           self->Disconnect( func );
1586       }
1587 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){
1588           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1589 /*@SWIG@*/ self->Emit( arg );
1590       }
1591 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1592          return self->Empty();
1593       }
1594 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){
1595         return self->GetConnectionCount();
1596       }
1597 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 &)){
1598           self->Connect( func );
1599       }
1600 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 &)){
1601           self->Disconnect( func );
1602       }
1603 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){
1604           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1605 /*@SWIG@*/ self->Emit( arg );
1606       }
1607
1608
1609 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){
1610          return self->Empty();
1611       }
1612 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){
1613         return self->GetConnectionCount();
1614       }
1615 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 &)){
1616         self->Connect( func );
1617       }
1618 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 &)){
1619         self->Disconnect( func );
1620       }
1621 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){
1622         return self->Emit( arg1, arg2 );
1623       }
1624 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1625          return self->Empty();
1626       }
1627 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1628         return self->GetConnectionCount();
1629       }
1630 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)){
1631           self->Connect( func );
1632       }
1633 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)){
1634           self->Disconnect( func );
1635       }
1636 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1637           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1638 /*@SWIG@*/ self->Emit( arg );
1639       }
1640 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1641          return self->Empty();
1642       }
1643 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1644         return self->GetConnectionCount();
1645       }
1646 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 &)){
1647           self->Connect( func );
1648       }
1649 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 &)){
1650           self->Disconnect( func );
1651       }
1652 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){
1653           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1654 /*@SWIG@*/ self->Emit( arg );
1655       }
1656 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1657          return self->Empty();
1658       }
1659 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){
1660         return self->GetConnectionCount();
1661       }
1662 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)){
1663         self->Connect( func );
1664       }
1665 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)){
1666         self->Disconnect( func );
1667       }
1668 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){
1669         return self->Emit( arg1, arg2 );
1670       }
1671 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1672          return self->Empty();
1673       }
1674 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){
1675         return self->GetConnectionCount();
1676       }
1677 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)){
1678         self->Connect( func );
1679       }
1680 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)){
1681         self->Disconnect( func );
1682       }
1683 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){
1684         return self->Emit( arg1, arg2 );
1685       }
1686
1687
1688 /* ---------------------------------------------------
1689  * C++ director class methods
1690  * --------------------------------------------------- */
1691
1692 #include "dali_wrap.h"
1693
1694 /*
1695  *  Widget director
1696  */
1697 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1698   swig_init_callbacks();
1699 }
1700
1701 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1702 }
1703
1704 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1705   char * jcontentInfo = 0 ;
1706   void * jwindow  ;
1707
1708   if (!swig_callbackOnCreate) {
1709     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1710     return;
1711   } else {
1712     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1713     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1714     swig_callbackOnCreate(jcontentInfo, jwindow);
1715   }
1716 }
1717
1718 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1719   char * jcontentInfo = 0 ;
1720   int jtype  ;
1721
1722   if (!swig_callbackOnTerminate) {
1723     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1724     return;
1725   } else {
1726     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1727     jtype = (int)type;
1728     swig_callbackOnTerminate(jcontentInfo, jtype);
1729   }
1730 }
1731
1732 void SwigDirector_WidgetImpl::OnPause() {
1733   if (!swig_callbackOnPause) {
1734     Dali::Internal::Adaptor::Widget::OnPause();
1735     return;
1736   } else {
1737     swig_callbackOnPause();
1738   }
1739 }
1740
1741 void SwigDirector_WidgetImpl::OnResume() {
1742   if (!swig_callbackOnResume) {
1743     Dali::Internal::Adaptor::Widget::OnResume();
1744     return;
1745   } else {
1746     swig_callbackOnResume();
1747   }
1748 }
1749
1750 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1751   void * jwindow  ;
1752
1753   if (!swig_callbackOnResize) {
1754     Dali::Internal::Adaptor::Widget::OnResize(window);
1755     return;
1756   } else {
1757     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1758     swig_callbackOnResize(jwindow);
1759   }
1760 }
1761
1762 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1763   char * jcontentInfo = 0 ;
1764   int jforce  ;
1765
1766   if (!swig_callbackOnUpdate) {
1767     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1768     return;
1769   } else {
1770     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1771     jforce = force;
1772     swig_callbackOnUpdate(jcontentInfo, jforce);
1773   }
1774 }
1775
1776 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1777   void * jslotObserver = 0 ;
1778   void * jcallback = 0 ;
1779
1780   if (!swig_callbackSignalConnected) {
1781     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1782     return;
1783   } else {
1784     jslotObserver = (void *) slotObserver;
1785     jcallback = (void *) callback;
1786     swig_callbackSignalConnected(jslotObserver, jcallback);
1787   }
1788 }
1789
1790 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1791   void * jslotObserver = 0 ;
1792   void * jcallback = 0 ;
1793
1794   if (!swig_callbackSignalDisconnected) {
1795     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1796     return;
1797   } else {
1798     jslotObserver = (void *) slotObserver;
1799     jcallback = (void *) callback;
1800     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1801   }
1802 }
1803
1804 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1805
1806   swig_callbackOnCreate = callbackOnCreate;
1807   swig_callbackOnTerminate = callbackOnTerminate;
1808   swig_callbackOnPause = callbackOnPause;
1809   swig_callbackOnResume = callbackOnResume;
1810   swig_callbackOnResize = callbackOnResize;
1811   swig_callbackOnUpdate = callbackOnUpdate;
1812   swig_callbackSignalConnected = callbackSignalConnected;
1813   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1814 }
1815
1816 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1817   swig_callbackOnCreate = 0;
1818   swig_callbackOnTerminate = 0;
1819   swig_callbackOnPause = 0;
1820   swig_callbackOnResume = 0;
1821   swig_callbackOnResize = 0;
1822   swig_callbackOnUpdate = 0;
1823   swig_callbackSignalConnected = 0;
1824   swig_callbackSignalDisconnected = 0;
1825 }
1826
1827
1828 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1829   swig_init_callbacks();
1830 }
1831
1832 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1833
1834 }
1835
1836
1837 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1838   int jdepth  ;
1839
1840   if (!swig_callbackOnStageConnection) {
1841     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1842     return;
1843   } else {
1844     jdepth = depth;
1845     swig_callbackOnStageConnection(jdepth);
1846   }
1847 }
1848
1849 void SwigDirector_ViewImpl::OnStageDisconnection() {
1850   if (!swig_callbackOnStageDisconnection) {
1851     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1852     return;
1853   } else {
1854     swig_callbackOnStageDisconnection();
1855   }
1856 }
1857
1858 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1859   void * jchild = 0 ;
1860
1861   if (!swig_callbackOnChildAdd) {
1862     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1863     return;
1864   } else {
1865     jchild = (Dali::Actor *) &child;
1866     swig_callbackOnChildAdd(jchild);
1867   }
1868 }
1869
1870 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1871   void * jchild = 0 ;
1872
1873   if (!swig_callbackOnChildRemove) {
1874     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1875     return;
1876   } else {
1877     jchild = (Dali::Actor *) &child;
1878     swig_callbackOnChildRemove(jchild);
1879   }
1880 }
1881
1882 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1883   int jindex  ;
1884   void * jpropertyValue  ;
1885
1886   if (!swig_callbackOnPropertySet) {
1887     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1888     return;
1889   } else {
1890     jindex = index;
1891     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1892     swig_callbackOnPropertySet(jindex, jpropertyValue);
1893   }
1894 }
1895
1896 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1897   void * jtargetSize = 0 ;
1898
1899   if (!swig_callbackOnSizeSet) {
1900     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1901     return;
1902   } else {
1903     jtargetSize = (Dali::Vector3 *) &targetSize;
1904     swig_callbackOnSizeSet(jtargetSize);
1905   }
1906 }
1907
1908 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1909   void * janimation = 0 ;
1910   void * jtargetSize = 0 ;
1911
1912   if (!swig_callbackOnSizeAnimation) {
1913     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1914     return;
1915   } else {
1916     janimation = (Dali::Animation *) &animation;
1917     jtargetSize = (Dali::Vector3 *) &targetSize;
1918     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1919   }
1920 }
1921
1922 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1923   bool c_result = SwigValueInit< bool >() ;
1924   unsigned int jresult = 0 ;
1925   void * jarg0 = 0 ;
1926
1927   if (!swig_callbackOnTouchEvent) {
1928     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1929   } else {
1930     jarg0 = (Dali::TouchEvent *) &event;
1931     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1932     c_result = jresult ? true : false;
1933   }
1934   return c_result;
1935 }
1936
1937 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1938   bool c_result = SwigValueInit< bool >() ;
1939   unsigned int jresult = 0 ;
1940   void * jarg0 = 0 ;
1941
1942   if (!swig_callbackOnHoverEvent) {
1943     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1944   } else {
1945     jarg0 = (Dali::HoverEvent *) &event;
1946     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1947     c_result = jresult ? true : false;
1948   }
1949   return c_result;
1950 }
1951
1952 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1953   bool c_result = SwigValueInit< bool >() ;
1954   unsigned int jresult = 0 ;
1955   void * jarg0 = 0 ;
1956
1957   if (!swig_callbackOnKeyEvent) {
1958     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1959   } else {
1960     jarg0 = (Dali::KeyEvent *) &event;
1961     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1962     c_result = jresult ? true : false;
1963   }
1964   return c_result;
1965 }
1966
1967 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1968   bool c_result = SwigValueInit< bool >() ;
1969   unsigned int jresult = 0 ;
1970   void * jarg0 = 0 ;
1971
1972   if (!swig_callbackOnWheelEvent) {
1973     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1974   } else {
1975     jarg0 = (Dali::WheelEvent *) &event;
1976     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1977     c_result = jresult ? true : false;
1978   }
1979   return c_result;
1980 }
1981
1982 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1983   void * jsize = 0 ;
1984   void * jcontainer = 0 ;
1985
1986   if (!swig_callbackOnRelayout) {
1987     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1988     return;
1989   } else {
1990     jsize = (Dali::Vector2 *) &size;
1991     jcontainer = (Dali::RelayoutContainer *) &container;
1992     swig_callbackOnRelayout(jsize, jcontainer);
1993   }
1994 }
1995
1996 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1997   int jpolicy  ;
1998   int jdimension  ;
1999
2000   if (!swig_callbackOnSetResizePolicy) {
2001     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2002     return;
2003   } else {
2004     jpolicy = (int)policy;
2005     jdimension = (int)dimension;
2006     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2007   }
2008 }
2009
2010 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2011   Dali::Vector3 c_result ;
2012   void * jresult = 0 ;
2013
2014   if (!swig_callbackGetNaturalSize) {
2015     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2016   } else {
2017     jresult = (void *) swig_callbackGetNaturalSize();
2018     if (!jresult) {
2019       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2020       return c_result;
2021     }
2022     c_result = *(Dali::Vector3 *)jresult;
2023   }
2024   return c_result;
2025 }
2026
2027 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2028   float c_result = SwigValueInit< float >() ;
2029   float jresult = 0 ;
2030   void * jchild = 0 ;
2031   int jdimension  ;
2032
2033   if (!swig_callbackCalculateChildSize) {
2034     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2035   } else {
2036     jchild = (Dali::Actor *) &child;
2037     jdimension = (int)dimension;
2038     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2039     c_result = (float)jresult;
2040   }
2041   return c_result;
2042 }
2043
2044 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2045   float c_result = SwigValueInit< float >() ;
2046   float jresult = 0 ;
2047   float jwidth  ;
2048
2049   if (!swig_callbackGetHeightForWidth) {
2050     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2051   } else {
2052     jwidth = width;
2053     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2054     c_result = (float)jresult;
2055   }
2056   return c_result;
2057 }
2058
2059 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2060   float c_result = SwigValueInit< float >() ;
2061   float jresult = 0 ;
2062   float jheight  ;
2063
2064   if (!swig_callbackGetWidthForHeight) {
2065     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2066   } else {
2067     jheight = height;
2068     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2069     c_result = (float)jresult;
2070   }
2071   return c_result;
2072 }
2073
2074 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2075   bool c_result = SwigValueInit< bool >() ;
2076   unsigned int jresult = 0 ;
2077   int jdimension  ;
2078
2079   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2080     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2081   } else {
2082     jdimension = (int)dimension;
2083     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2084     c_result = jresult ? true : false;
2085   }
2086   return c_result;
2087 }
2088
2089 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2090   int jdimension  ;
2091
2092   if (!swig_callbackOnCalculateRelayoutSize) {
2093     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2094     return;
2095   } else {
2096     jdimension = (int)dimension;
2097     swig_callbackOnCalculateRelayoutSize(jdimension);
2098   }
2099 }
2100
2101 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2102   float jsize  ;
2103   int jdimension  ;
2104
2105   if (!swig_callbackOnLayoutNegotiated) {
2106     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2107     return;
2108   } else {
2109     jsize = size;
2110     jdimension = (int)dimension;
2111     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2112   }
2113 }
2114
2115 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2116   return Dali::CustomActorImpl::GetExtension();
2117 }
2118
2119 void SwigDirector_ViewImpl::OnInitialize() {
2120   if (!swig_callbackOnInitialize) {
2121     Dali::Toolkit::Internal::Control::OnInitialize();
2122     return;
2123   } else {
2124     swig_callbackOnInitialize();
2125   }
2126 }
2127
2128 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2129   void * jchild = 0 ;
2130
2131   if (!swig_callbackOnControlChildAdd) {
2132     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2133     return;
2134   } else {
2135     jchild = (Dali::Actor *) &child;
2136     swig_callbackOnControlChildAdd(jchild);
2137   }
2138 }
2139
2140 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2141   void * jchild = 0 ;
2142
2143   if (!swig_callbackOnControlChildRemove) {
2144     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2145     return;
2146   } else {
2147     jchild = (Dali::Actor *) &child;
2148     swig_callbackOnControlChildRemove(jchild);
2149   }
2150 }
2151
2152 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2153   void * jstyleManager  ;
2154   int jchange  ;
2155
2156   if (!swig_callbackOnStyleChange) {
2157     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2158     return;
2159   } else {
2160     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2161     jchange = (int)change;
2162     swig_callbackOnStyleChange(jstyleManager, jchange);
2163   }
2164 }
2165
2166 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2167   bool c_result = SwigValueInit< bool >() ;
2168   unsigned int jresult = 0 ;
2169
2170   if (!swig_callbackOnAccessibilityActivated) {
2171     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2172   } else {
2173     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2174     c_result = jresult ? true : false;
2175   }
2176   return c_result;
2177 }
2178
2179 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2180   bool c_result = SwigValueInit< bool >() ;
2181   unsigned int jresult = 0 ;
2182   void * jgesture  ;
2183
2184   if (!swig_callbackOnAccessibilityPan) {
2185     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2186   } else {
2187     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2188     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2189     c_result = jresult ? true : false;
2190   }
2191   return c_result;
2192 }
2193
2194 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2195   bool c_result = SwigValueInit< bool >() ;
2196   unsigned int jresult = 0 ;
2197   void * jtouchEvent = 0 ;
2198
2199   if (!swig_callbackOnAccessibilityTouch) {
2200     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2201   } else {
2202     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2203     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2204     c_result = jresult ? true : false;
2205   }
2206   return c_result;
2207 }
2208
2209 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2210   bool c_result = SwigValueInit< bool >() ;
2211   unsigned int jresult = 0 ;
2212   unsigned int jisIncrease  ;
2213
2214   if (!swig_callbackOnAccessibilityValueChange) {
2215     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2216   } else {
2217     jisIncrease = isIncrease;
2218     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2219     c_result = jresult ? true : false;
2220   }
2221   return c_result;
2222 }
2223
2224 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2225   bool c_result = SwigValueInit< bool >() ;
2226   unsigned int jresult = 0 ;
2227
2228   if (!swig_callbackOnAccessibilityZoom) {
2229     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2230   } else {
2231     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2232     c_result = jresult ? true : false;
2233   }
2234   return c_result;
2235 }
2236
2237 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2238   if (!swig_callbackOnKeyInputFocusGained) {
2239     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2240     return;
2241   } else {
2242     swig_callbackOnKeyInputFocusGained();
2243   }
2244 }
2245
2246 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2247   if (!swig_callbackOnKeyInputFocusLost) {
2248     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2249     return;
2250   } else {
2251     swig_callbackOnKeyInputFocusLost();
2252   }
2253 }
2254
2255 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2256   Dali::Actor c_result ;
2257   void * jresult = 0 ;
2258   void * jcurrentFocusedActor  ;
2259   int jdirection  ;
2260   unsigned int jloopEnabled  ;
2261
2262   if (!swig_callbackGetNextKeyboardFocusableActor) {
2263     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2264   } else {
2265     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2266     jdirection = (int)direction;
2267     jloopEnabled = loopEnabled;
2268     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2269     if (!jresult) {
2270       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2271       return c_result;
2272     }
2273     c_result = *(Dali::Actor *)jresult;
2274   }
2275   return c_result;
2276 }
2277
2278 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2279   void * jcommitedFocusableActor  ;
2280
2281   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2282     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2283     return;
2284   } else {
2285     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2286     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2287   }
2288 }
2289
2290 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2291   bool c_result = SwigValueInit< bool >() ;
2292   unsigned int jresult = 0 ;
2293
2294   if (!swig_callbackOnKeyboardEnter) {
2295     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2296   } else {
2297     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2298     c_result = jresult ? true : false;
2299   }
2300   return c_result;
2301 }
2302
2303 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2304   void * jpinch = 0 ;
2305
2306   if (!swig_callbackOnPinch) {
2307     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2308     return;
2309   } else {
2310     jpinch = (Dali::PinchGesture *) &pinch;
2311     swig_callbackOnPinch(jpinch);
2312   }
2313 }
2314
2315 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2316   void * jpan = 0 ;
2317
2318   if (!swig_callbackOnPan) {
2319     Dali::Toolkit::Internal::Control::OnPan(pan);
2320     return;
2321   } else {
2322     jpan = (Dali::PanGesture *) &pan;
2323     swig_callbackOnPan(jpan);
2324   }
2325 }
2326
2327 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2328   void * jtap = 0 ;
2329
2330   if (!swig_callbackOnTap) {
2331     Dali::Toolkit::Internal::Control::OnTap(tap);
2332     return;
2333   } else {
2334     jtap = (Dali::TapGesture *) &tap;
2335     swig_callbackOnTap(jtap);
2336   }
2337 }
2338
2339 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2340   void * jlongPress = 0 ;
2341
2342   if (!swig_callbackOnLongPress) {
2343     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2344     return;
2345   } else {
2346     jlongPress = (Dali::LongPressGesture *) &longPress;
2347     swig_callbackOnLongPress(jlongPress);
2348   }
2349 }
2350
2351 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2352   void * jslotObserver = 0 ;
2353   void * jcallback = 0 ;
2354
2355   if (!swig_callbackSignalConnected) {
2356     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2357     return;
2358   } else {
2359     jslotObserver = (void *) slotObserver;
2360     jcallback = (void *) callback;
2361     swig_callbackSignalConnected(jslotObserver, jcallback);
2362   }
2363 }
2364
2365 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2366   void * jslotObserver = 0 ;
2367   void * jcallback = 0 ;
2368
2369   if (!swig_callbackSignalDisconnected) {
2370     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2371     return;
2372   } else {
2373     jslotObserver = (void *) slotObserver;
2374     jcallback = (void *) callback;
2375     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2376   }
2377 }
2378
2379 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2380   return Dali::Toolkit::Internal::Control::GetControlExtension();
2381 }
2382
2383 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) {
2384   swig_callbackOnStageConnection = callbackOnStageConnection;
2385   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2386   swig_callbackOnChildAdd = callbackOnChildAdd;
2387   swig_callbackOnChildRemove = callbackOnChildRemove;
2388   swig_callbackOnPropertySet = callbackOnPropertySet;
2389   swig_callbackOnSizeSet = callbackOnSizeSet;
2390   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2391   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2392   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2393   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2394   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2395   swig_callbackOnRelayout = callbackOnRelayout;
2396   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2397   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2398   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2399   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2400   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2401   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2402   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2403   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2404   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2405   swig_callbackOnInitialize = callbackOnInitialize;
2406   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2407   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2408   swig_callbackOnStyleChange = callbackOnStyleChange;
2409   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2410   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2411   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2412   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2413   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2414   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2415   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2416   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2417   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2418   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2419   swig_callbackOnPinch = callbackOnPinch;
2420   swig_callbackOnPan = callbackOnPan;
2421   swig_callbackOnTap = callbackOnTap;
2422   swig_callbackOnLongPress = callbackOnLongPress;
2423   swig_callbackSignalConnected = callbackSignalConnected;
2424   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2425 }
2426
2427 void SwigDirector_ViewImpl::swig_init_callbacks() {
2428   swig_callbackOnStageConnection = 0;
2429   swig_callbackOnStageDisconnection = 0;
2430   swig_callbackOnChildAdd = 0;
2431   swig_callbackOnChildRemove = 0;
2432   swig_callbackOnPropertySet = 0;
2433   swig_callbackOnSizeSet = 0;
2434   swig_callbackOnSizeAnimation = 0;
2435   swig_callbackOnTouchEvent = 0;
2436   swig_callbackOnHoverEvent = 0;
2437   swig_callbackOnKeyEvent = 0;
2438   swig_callbackOnWheelEvent = 0;
2439   swig_callbackOnRelayout = 0;
2440   swig_callbackOnSetResizePolicy = 0;
2441   swig_callbackGetNaturalSize = 0;
2442   swig_callbackCalculateChildSize = 0;
2443   swig_callbackGetHeightForWidth = 0;
2444   swig_callbackGetWidthForHeight = 0;
2445   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2446   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2447   swig_callbackOnCalculateRelayoutSize = 0;
2448   swig_callbackOnLayoutNegotiated = 0;
2449   swig_callbackOnInitialize = 0;
2450   swig_callbackOnControlChildAdd = 0;
2451   swig_callbackOnControlChildRemove = 0;
2452   swig_callbackOnStyleChange = 0;
2453   swig_callbackOnAccessibilityActivated = 0;
2454   swig_callbackOnAccessibilityPan = 0;
2455   swig_callbackOnAccessibilityTouch = 0;
2456   swig_callbackOnAccessibilityValueChange = 0;
2457   swig_callbackOnAccessibilityZoom = 0;
2458   swig_callbackOnKeyInputFocusGained = 0;
2459   swig_callbackOnKeyInputFocusLost = 0;
2460   swig_callbackGetNextKeyboardFocusableActor = 0;
2461   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2462   swig_callbackOnKeyboardEnter = 0;
2463   swig_callbackOnPinch = 0;
2464   swig_callbackOnPan = 0;
2465   swig_callbackOnTap = 0;
2466   swig_callbackOnLongPress = 0;
2467   swig_callbackSignalConnected = 0;
2468   swig_callbackSignalDisconnected = 0;
2469 }
2470
2471 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2472   swig_init_callbacks();
2473 }
2474
2475 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2476
2477 }
2478
2479
2480 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2481   unsigned int c_result = SwigValueInit< unsigned int >() ;
2482   unsigned int jresult = 0 ;
2483
2484   if (!swig_callbackGetNumberOfItems) {
2485     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2486   } else {
2487     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2488     c_result = (unsigned int)jresult;
2489   }
2490   return c_result;
2491 }
2492
2493 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2494   Dali::Actor c_result ;
2495   void * jresult = 0 ;
2496   unsigned int jitemId  ;
2497
2498   if (!swig_callbackNewItem) {
2499     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2500   } else {
2501     jitemId = itemId;
2502     jresult = (void *) swig_callbackNewItem(jitemId);
2503     if (!jresult) {
2504       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2505       return c_result;
2506     }
2507     c_result = *(Dali::Actor *)jresult;
2508   }
2509   return c_result;
2510 }
2511
2512 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2513   unsigned int jitemId  ;
2514   void * jactor  ;
2515
2516   if (!swig_callbackItemReleased) {
2517     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2518     return;
2519   } else {
2520     jitemId = itemId;
2521     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2522     swig_callbackItemReleased(jitemId, jactor);
2523   }
2524 }
2525
2526 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2527   return Dali::Toolkit::ItemFactory::GetExtension();
2528 }
2529
2530 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2531   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2532   swig_callbackNewItem = callbackNewItem;
2533   swig_callbackItemReleased = callbackItemReleased;
2534 }
2535
2536 void SwigDirector_ItemFactory::swig_init_callbacks() {
2537   swig_callbackGetNumberOfItems = 0;
2538   swig_callbackNewItem = 0;
2539   swig_callbackItemReleased = 0;
2540 }
2541
2542 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2543   swig_init_callbacks();
2544 }
2545
2546 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2547
2548 }
2549
2550
2551 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2552   Dali::Actor c_result ;
2553   void * jresult = 0 ;
2554   void * jcurrent  ;
2555   void * jproposed  ;
2556   int jdirection  ;
2557
2558   if (!swig_callbackGetNextFocusableActor) {
2559     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2560   } else {
2561     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2562     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2563     jdirection = (int)direction;
2564     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2565     if (!jresult) {
2566       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2567       return c_result;
2568     }
2569     c_result = *(Dali::Actor *)jresult;
2570   }
2571   return c_result;
2572 }
2573
2574 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2575   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2576 }
2577
2578 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2579   swig_callbackGetNextFocusableActor = 0;
2580 }
2581
2582
2583 #ifdef __cplusplus
2584 extern "C" {
2585 #endif
2586
2587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2588   void * jresult ;
2589   floatp *result = 0 ;
2590
2591   {
2592     try {
2593       result = (floatp *)new_floatp();
2594     } catch (std::out_of_range& e) {
2595       {
2596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2597       };
2598     } catch (std::exception& e) {
2599       {
2600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2601       };
2602     } catch (DaliException e) {
2603       {
2604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2605       };
2606     } catch (...) {
2607       {
2608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2609       };
2610     }
2611   }
2612   jresult = (void *)result;
2613   return jresult;
2614 }
2615
2616
2617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2618   floatp *arg1 = (floatp *) 0 ;
2619
2620   arg1 = (floatp *)jarg1;
2621   {
2622     try {
2623       delete_floatp(arg1);
2624     } catch (std::out_of_range& e) {
2625       {
2626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2627       };
2628     } catch (std::exception& e) {
2629       {
2630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2631       };
2632     } catch (Dali::DaliException e) {
2633       {
2634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2635       };
2636     } catch (...) {
2637       {
2638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2639       };
2640     }
2641   }
2642
2643 }
2644
2645
2646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2647   floatp *arg1 = (floatp *) 0 ;
2648   float arg2 ;
2649
2650   arg1 = (floatp *)jarg1;
2651   arg2 = (float)jarg2;
2652   {
2653     try {
2654       floatp_assign(arg1,arg2);
2655     } catch (std::out_of_range& e) {
2656       {
2657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2658       };
2659     } catch (std::exception& e) {
2660       {
2661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2662       };
2663     } catch (Dali::DaliException e) {
2664       {
2665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2666       };
2667     } catch (...) {
2668       {
2669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2670       };
2671     }
2672   }
2673
2674 }
2675
2676
2677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2678   float jresult ;
2679   floatp *arg1 = (floatp *) 0 ;
2680   float result;
2681
2682   arg1 = (floatp *)jarg1;
2683   {
2684     try {
2685       result = (float)floatp_value(arg1);
2686     } catch (std::out_of_range& e) {
2687       {
2688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2689       };
2690     } catch (std::exception& e) {
2691       {
2692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2693       };
2694     } catch (DaliException e) {
2695       {
2696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2697       };
2698     } catch (...) {
2699       {
2700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2701       };
2702     }
2703   }
2704   jresult = result;
2705   return jresult;
2706 }
2707
2708
2709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2710   void * jresult ;
2711   floatp *arg1 = (floatp *) 0 ;
2712   float *result = 0 ;
2713
2714   arg1 = (floatp *)jarg1;
2715   {
2716     try {
2717       result = (float *)floatp_cast(arg1);
2718     } catch (std::out_of_range& e) {
2719       {
2720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2721       };
2722     } catch (std::exception& e) {
2723       {
2724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2725       };
2726     } catch (Dali::DaliException e) {
2727       {
2728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2729       };
2730     } catch (...) {
2731       {
2732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2733       };
2734     }
2735   }
2736
2737   jresult = (void *)result;
2738   return jresult;
2739 }
2740
2741
2742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2743   void * jresult ;
2744   float *arg1 = (float *) 0 ;
2745   floatp *result = 0 ;
2746
2747   arg1 = (float *)jarg1;
2748   {
2749     try {
2750       result = (floatp *)floatp_frompointer(arg1);
2751     } catch (std::out_of_range& e) {
2752       {
2753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2754       };
2755     } catch (std::exception& e) {
2756       {
2757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2758       };
2759     } catch (Dali::DaliException e) {
2760       {
2761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2762       };
2763     } catch (...) {
2764       {
2765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2766       };
2767     }
2768   }
2769
2770   jresult = (void *)result;
2771   return jresult;
2772 }
2773
2774
2775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2776   void * jresult ;
2777   intp *result = 0 ;
2778
2779   {
2780     try {
2781       result = (intp *)new_intp();
2782     } catch (std::out_of_range& e) {
2783       {
2784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2785       };
2786     } catch (std::exception& e) {
2787       {
2788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2789       };
2790     } catch (Dali::DaliException e) {
2791       {
2792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2793       };
2794     } catch (...) {
2795       {
2796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2797       };
2798     }
2799   }
2800
2801   jresult = (void *)result;
2802   return jresult;
2803 }
2804
2805
2806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2807   intp *arg1 = (intp *) 0 ;
2808
2809   arg1 = (intp *)jarg1;
2810   {
2811     try {
2812       delete_intp(arg1);
2813     } catch (std::out_of_range& e) {
2814       {
2815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2816       };
2817     } catch (std::exception& e) {
2818       {
2819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2820       };
2821     } catch (Dali::DaliException e) {
2822       {
2823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2824       };
2825     } catch (...) {
2826       {
2827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2828       };
2829     }
2830   }
2831
2832 }
2833
2834
2835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2836   intp *arg1 = (intp *) 0 ;
2837   int arg2 ;
2838
2839   arg1 = (intp *)jarg1;
2840   arg2 = (int)jarg2;
2841   {
2842     try {
2843       intp_assign(arg1,arg2);
2844     } catch (std::out_of_range& e) {
2845       {
2846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2847       };
2848     } catch (std::exception& e) {
2849       {
2850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2851       };
2852     } catch (Dali::DaliException e) {
2853       {
2854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2855       };
2856     } catch (...) {
2857       {
2858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2859       };
2860     }
2861   }
2862
2863 }
2864
2865
2866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2867   int jresult ;
2868   intp *arg1 = (intp *) 0 ;
2869   int result;
2870
2871   arg1 = (intp *)jarg1;
2872   {
2873     try {
2874       result = (int)intp_value(arg1);
2875     } catch (std::out_of_range& e) {
2876       {
2877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2878       };
2879     } catch (std::exception& e) {
2880       {
2881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2882       };
2883     } catch (Dali::DaliException e) {
2884       {
2885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2886       };
2887     } catch (...) {
2888       {
2889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2890       };
2891     }
2892   }
2893
2894   jresult = result;
2895   return jresult;
2896 }
2897
2898
2899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2900   void * jresult ;
2901   intp *arg1 = (intp *) 0 ;
2902   int *result = 0 ;
2903
2904   arg1 = (intp *)jarg1;
2905   {
2906     try {
2907       result = (int *)intp_cast(arg1);
2908     } catch (std::out_of_range& e) {
2909       {
2910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2911       };
2912     } catch (std::exception& e) {
2913       {
2914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2915       };
2916     } catch (Dali::DaliException e) {
2917       {
2918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2919       };
2920     } catch (...) {
2921       {
2922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2923       };
2924     }
2925   }
2926
2927   jresult = (void *)result;
2928   return jresult;
2929 }
2930
2931
2932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2933   void * jresult ;
2934   int *arg1 = (int *) 0 ;
2935   intp *result = 0 ;
2936
2937   arg1 = (int *)jarg1;
2938   {
2939     try {
2940       result = (intp *)intp_frompointer(arg1);
2941     } catch (std::out_of_range& e) {
2942       {
2943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2944       };
2945     } catch (std::exception& e) {
2946       {
2947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2948       };
2949     } catch (Dali::DaliException e) {
2950       {
2951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2952       };
2953     } catch (...) {
2954       {
2955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2956       };
2957     }
2958   }
2959
2960   jresult = (void *)result;
2961   return jresult;
2962 }
2963
2964
2965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2966   void * jresult ;
2967   doublep *result = 0 ;
2968
2969   {
2970     try {
2971       result = (doublep *)new_doublep();
2972     } catch (std::out_of_range& e) {
2973       {
2974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2975       };
2976     } catch (std::exception& e) {
2977       {
2978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2979       };
2980     } catch (Dali::DaliException e) {
2981       {
2982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2983       };
2984     } catch (...) {
2985       {
2986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2987       };
2988     }
2989   }
2990
2991   jresult = (void *)result;
2992   return jresult;
2993 }
2994
2995
2996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2997   doublep *arg1 = (doublep *) 0 ;
2998
2999   arg1 = (doublep *)jarg1;
3000   {
3001     try {
3002       delete_doublep(arg1);
3003     } catch (std::out_of_range& e) {
3004       {
3005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3006       };
3007     } catch (std::exception& e) {
3008       {
3009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3010       };
3011     } catch (Dali::DaliException e) {
3012       {
3013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3014       };
3015     } catch (...) {
3016       {
3017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3018       };
3019     }
3020   }
3021
3022 }
3023
3024
3025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3026   doublep *arg1 = (doublep *) 0 ;
3027   double arg2 ;
3028
3029   arg1 = (doublep *)jarg1;
3030   arg2 = (double)jarg2;
3031   {
3032     try {
3033       doublep_assign(arg1,arg2);
3034     } catch (std::out_of_range& e) {
3035       {
3036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3037       };
3038     } catch (std::exception& e) {
3039       {
3040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3041       };
3042     } catch (Dali::DaliException e) {
3043       {
3044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3045       };
3046     } catch (...) {
3047       {
3048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3049       };
3050     }
3051   }
3052
3053 }
3054
3055
3056 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3057   double jresult ;
3058   doublep *arg1 = (doublep *) 0 ;
3059   double result;
3060
3061   arg1 = (doublep *)jarg1;
3062   {
3063     try {
3064       result = (double)doublep_value(arg1);
3065     } catch (std::out_of_range& e) {
3066       {
3067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3068       };
3069     } catch (std::exception& e) {
3070       {
3071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3072       };
3073     } catch (Dali::DaliException e) {
3074       {
3075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3076       };
3077     } catch (...) {
3078       {
3079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3080       };
3081     }
3082   }
3083
3084   jresult = result;
3085   return jresult;
3086 }
3087
3088
3089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3090   void * jresult ;
3091   doublep *arg1 = (doublep *) 0 ;
3092   double *result = 0 ;
3093
3094   arg1 = (doublep *)jarg1;
3095   {
3096     try {
3097       result = (double *)doublep_cast(arg1);
3098     } catch (std::out_of_range& e) {
3099       {
3100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3101       };
3102     } catch (std::exception& e) {
3103       {
3104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3105       };
3106     } catch (Dali::DaliException e) {
3107       {
3108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3109       };
3110     } catch (...) {
3111       {
3112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3113       };
3114     }
3115   }
3116
3117   jresult = (void *)result;
3118   return jresult;
3119 }
3120
3121
3122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3123   void * jresult ;
3124   double *arg1 = (double *) 0 ;
3125   doublep *result = 0 ;
3126
3127   arg1 = (double *)jarg1;
3128   {
3129     try {
3130       result = (doublep *)doublep_frompointer(arg1);
3131     } catch (std::out_of_range& e) {
3132       {
3133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3134       };
3135     } catch (std::exception& e) {
3136       {
3137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3138       };
3139     } catch (Dali::DaliException e) {
3140       {
3141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3142       };
3143     } catch (...) {
3144       {
3145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3146       };
3147     }
3148   }
3149
3150   jresult = (void *)result;
3151   return jresult;
3152 }
3153
3154
3155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3156   void * jresult ;
3157   uintp *result = 0 ;
3158
3159   {
3160     try {
3161       result = (uintp *)new_uintp();
3162     } catch (std::out_of_range& e) {
3163       {
3164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3165       };
3166     } catch (std::exception& e) {
3167       {
3168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3169       };
3170     } catch (Dali::DaliException e) {
3171       {
3172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3173       };
3174     } catch (...) {
3175       {
3176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3177       };
3178     }
3179   }
3180
3181   jresult = (void *)result;
3182   return jresult;
3183 }
3184
3185
3186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3187   uintp *arg1 = (uintp *) 0 ;
3188
3189   arg1 = (uintp *)jarg1;
3190   {
3191     try {
3192       delete_uintp(arg1);
3193     } catch (std::out_of_range& e) {
3194       {
3195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3196       };
3197     } catch (std::exception& e) {
3198       {
3199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3200       };
3201     } catch (Dali::DaliException e) {
3202       {
3203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3204       };
3205     } catch (...) {
3206       {
3207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3208       };
3209     }
3210   }
3211
3212 }
3213
3214
3215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3216   uintp *arg1 = (uintp *) 0 ;
3217   unsigned int arg2 ;
3218
3219   arg1 = (uintp *)jarg1;
3220   arg2 = (unsigned int)jarg2;
3221   {
3222     try {
3223       uintp_assign(arg1,arg2);
3224     } catch (std::out_of_range& e) {
3225       {
3226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3227       };
3228     } catch (std::exception& e) {
3229       {
3230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3231       };
3232     } catch (Dali::DaliException e) {
3233       {
3234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3235       };
3236     } catch (...) {
3237       {
3238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3239       };
3240     }
3241   }
3242
3243 }
3244
3245
3246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3247   unsigned int jresult ;
3248   uintp *arg1 = (uintp *) 0 ;
3249   unsigned int result;
3250
3251   arg1 = (uintp *)jarg1;
3252   {
3253     try {
3254       result = (unsigned int)uintp_value(arg1);
3255     } catch (std::out_of_range& e) {
3256       {
3257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3258       };
3259     } catch (std::exception& e) {
3260       {
3261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3262       };
3263     } catch (Dali::DaliException e) {
3264       {
3265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3266       };
3267     } catch (...) {
3268       {
3269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3270       };
3271     }
3272   }
3273
3274   jresult = result;
3275   return jresult;
3276 }
3277
3278
3279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3280   void * jresult ;
3281   uintp *arg1 = (uintp *) 0 ;
3282   unsigned int *result = 0 ;
3283
3284   arg1 = (uintp *)jarg1;
3285   {
3286     try {
3287       result = (unsigned int *)uintp_cast(arg1);
3288     } catch (std::out_of_range& e) {
3289       {
3290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3291       };
3292     } catch (std::exception& e) {
3293       {
3294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3295       };
3296     } catch (Dali::DaliException e) {
3297       {
3298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3299       };
3300     } catch (...) {
3301       {
3302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3303       };
3304     }
3305   }
3306
3307   jresult = (void *)result;
3308   return jresult;
3309 }
3310
3311
3312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3313   void * jresult ;
3314   unsigned int *arg1 = (unsigned int *) 0 ;
3315   uintp *result = 0 ;
3316
3317   arg1 = (unsigned int *)jarg1;
3318   {
3319     try {
3320       result = (uintp *)uintp_frompointer(arg1);
3321     } catch (std::out_of_range& e) {
3322       {
3323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3324       };
3325     } catch (std::exception& e) {
3326       {
3327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3328       };
3329     } catch (Dali::DaliException e) {
3330       {
3331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3332       };
3333     } catch (...) {
3334       {
3335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3336       };
3337     }
3338   }
3339
3340   jresult = (void *)result;
3341   return jresult;
3342 }
3343
3344
3345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3346   void * jresult ;
3347   ushortp *result = 0 ;
3348
3349   {
3350     try {
3351       result = (ushortp *)new_ushortp();
3352     } catch (std::out_of_range& e) {
3353       {
3354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3355       };
3356     } catch (std::exception& e) {
3357       {
3358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3359       };
3360     } catch (Dali::DaliException e) {
3361       {
3362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3363       };
3364     } catch (...) {
3365       {
3366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3367       };
3368     }
3369   }
3370
3371   jresult = (void *)result;
3372   return jresult;
3373 }
3374
3375
3376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3377   ushortp *arg1 = (ushortp *) 0 ;
3378
3379   arg1 = (ushortp *)jarg1;
3380   {
3381     try {
3382       delete_ushortp(arg1);
3383     } catch (std::out_of_range& e) {
3384       {
3385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3386       };
3387     } catch (std::exception& e) {
3388       {
3389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3390       };
3391     } catch (Dali::DaliException e) {
3392       {
3393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3394       };
3395     } catch (...) {
3396       {
3397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3398       };
3399     }
3400   }
3401
3402 }
3403
3404
3405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3406   ushortp *arg1 = (ushortp *) 0 ;
3407   unsigned short arg2 ;
3408
3409   arg1 = (ushortp *)jarg1;
3410   arg2 = (unsigned short)jarg2;
3411   {
3412     try {
3413       ushortp_assign(arg1,arg2);
3414     } catch (std::out_of_range& e) {
3415       {
3416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3417       };
3418     } catch (std::exception& e) {
3419       {
3420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3421       };
3422     } catch (Dali::DaliException e) {
3423       {
3424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3425       };
3426     } catch (...) {
3427       {
3428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3429       };
3430     }
3431   }
3432
3433 }
3434
3435
3436 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3437   unsigned short jresult ;
3438   ushortp *arg1 = (ushortp *) 0 ;
3439   unsigned short result;
3440
3441   arg1 = (ushortp *)jarg1;
3442   {
3443     try {
3444       result = (unsigned short)ushortp_value(arg1);
3445     } catch (std::out_of_range& e) {
3446       {
3447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3448       };
3449     } catch (std::exception& e) {
3450       {
3451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3452       };
3453     } catch (Dali::DaliException e) {
3454       {
3455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3456       };
3457     } catch (...) {
3458       {
3459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3460       };
3461     }
3462   }
3463
3464   jresult = result;
3465   return jresult;
3466 }
3467
3468
3469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3470   void * jresult ;
3471   ushortp *arg1 = (ushortp *) 0 ;
3472   unsigned short *result = 0 ;
3473
3474   arg1 = (ushortp *)jarg1;
3475   {
3476     try {
3477       result = (unsigned short *)ushortp_cast(arg1);
3478     } catch (std::out_of_range& e) {
3479       {
3480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3481       };
3482     } catch (std::exception& e) {
3483       {
3484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3485       };
3486     } catch (Dali::DaliException e) {
3487       {
3488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3489       };
3490     } catch (...) {
3491       {
3492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3493       };
3494     }
3495   }
3496
3497   jresult = (void *)result;
3498   return jresult;
3499 }
3500
3501
3502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3503   void * jresult ;
3504   unsigned short *arg1 = (unsigned short *) 0 ;
3505   ushortp *result = 0 ;
3506
3507   arg1 = (unsigned short *)jarg1;
3508   {
3509     try {
3510       result = (ushortp *)ushortp_frompointer(arg1);
3511     } catch (std::out_of_range& e) {
3512       {
3513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3514       };
3515     } catch (std::exception& e) {
3516       {
3517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3518       };
3519     } catch (Dali::DaliException e) {
3520       {
3521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3522       };
3523     } catch (...) {
3524       {
3525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3526       };
3527     }
3528   }
3529
3530   jresult = (void *)result;
3531   return jresult;
3532 }
3533
3534
3535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3536   unsigned int jresult ;
3537   int arg1 ;
3538   unsigned int result;
3539
3540   arg1 = (int)jarg1;
3541   {
3542     try {
3543       result = (unsigned int)int_to_uint(arg1);
3544     } catch (std::out_of_range& e) {
3545       {
3546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3547       };
3548     } catch (std::exception& e) {
3549       {
3550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3551       };
3552     } catch (Dali::DaliException e) {
3553       {
3554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3555       };
3556     } catch (...) {
3557       {
3558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3559       };
3560     }
3561   }
3562
3563   jresult = result;
3564   return jresult;
3565 }
3566
3567
3568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3569   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3570
3571   arg1 = (Dali::RefObject *)jarg1;
3572   {
3573     try {
3574       (arg1)->Reference();
3575     } catch (std::out_of_range& e) {
3576       {
3577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3578       };
3579     } catch (std::exception& e) {
3580       {
3581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3582       };
3583     } catch (Dali::DaliException e) {
3584       {
3585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3586       };
3587     } catch (...) {
3588       {
3589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3590       };
3591     }
3592   }
3593
3594 }
3595
3596
3597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3598   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3599
3600   arg1 = (Dali::RefObject *)jarg1;
3601   {
3602     try {
3603       (arg1)->Unreference();
3604     } catch (std::out_of_range& e) {
3605       {
3606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3607       };
3608     } catch (std::exception& e) {
3609       {
3610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3611       };
3612     } catch (Dali::DaliException e) {
3613       {
3614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3615       };
3616     } catch (...) {
3617       {
3618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3619       };
3620     }
3621   }
3622
3623 }
3624
3625
3626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3627   int jresult ;
3628   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3629   int result;
3630
3631   arg1 = (Dali::RefObject *)jarg1;
3632   {
3633     try {
3634       result = (int)(arg1)->ReferenceCount();
3635     } catch (std::out_of_range& e) {
3636       {
3637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3638       };
3639     } catch (std::exception& e) {
3640       {
3641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3642       };
3643     } catch (Dali::DaliException e) {
3644       {
3645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3646       };
3647     } catch (...) {
3648       {
3649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3650       };
3651     }
3652   }
3653
3654   jresult = result;
3655   return jresult;
3656 }
3657
3658
3659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3660   void * jresult ;
3661   Dali::Any *result = 0 ;
3662
3663   {
3664     try {
3665       result = (Dali::Any *)new Dali::Any();
3666     } catch (std::out_of_range& e) {
3667       {
3668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3669       };
3670     } catch (std::exception& e) {
3671       {
3672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3673       };
3674     } catch (Dali::DaliException e) {
3675       {
3676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3677       };
3678     } catch (...) {
3679       {
3680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3681       };
3682     }
3683   }
3684
3685   jresult = (void *)result;
3686   return jresult;
3687 }
3688
3689
3690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3691   Dali::Any *arg1 = (Dali::Any *) 0 ;
3692
3693   arg1 = (Dali::Any *)jarg1;
3694   {
3695     try {
3696       delete arg1;
3697     } catch (std::out_of_range& e) {
3698       {
3699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3700       };
3701     } catch (std::exception& e) {
3702       {
3703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3704       };
3705     } catch (Dali::DaliException e) {
3706       {
3707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3708       };
3709     } catch (...) {
3710       {
3711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3712       };
3713     }
3714   }
3715
3716 }
3717
3718
3719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3720   char *arg1 = (char *) 0 ;
3721
3722   arg1 = (char *)jarg1;
3723   {
3724     try {
3725       Dali::Any::AssertAlways((char const *)arg1);
3726     } catch (std::out_of_range& e) {
3727       {
3728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3729       };
3730     } catch (std::exception& e) {
3731       {
3732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3733       };
3734     } catch (Dali::DaliException e) {
3735       {
3736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3737       };
3738     } catch (...) {
3739       {
3740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3741       };
3742     }
3743   }
3744
3745 }
3746
3747
3748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3749   void * jresult ;
3750   Dali::Any *arg1 = 0 ;
3751   Dali::Any *result = 0 ;
3752
3753   arg1 = (Dali::Any *)jarg1;
3754   if (!arg1) {
3755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3756     return 0;
3757   }
3758   {
3759     try {
3760       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3761     } catch (std::out_of_range& e) {
3762       {
3763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3764       };
3765     } catch (std::exception& e) {
3766       {
3767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3768       };
3769     } catch (Dali::DaliException e) {
3770       {
3771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3772       };
3773     } catch (...) {
3774       {
3775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3776       };
3777     }
3778   }
3779
3780   jresult = (void *)result;
3781   return jresult;
3782 }
3783
3784
3785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3786   void * jresult ;
3787   Dali::Any *arg1 = (Dali::Any *) 0 ;
3788   Dali::Any *arg2 = 0 ;
3789   Dali::Any *result = 0 ;
3790
3791   arg1 = (Dali::Any *)jarg1;
3792   arg2 = (Dali::Any *)jarg2;
3793   if (!arg2) {
3794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3795     return 0;
3796   }
3797   {
3798     try {
3799       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3800     } catch (std::out_of_range& e) {
3801       {
3802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3803       };
3804     } catch (std::exception& e) {
3805       {
3806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3807       };
3808     } catch (Dali::DaliException e) {
3809       {
3810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3811       };
3812     } catch (...) {
3813       {
3814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3815       };
3816     }
3817   }
3818
3819   jresult = (void *)result;
3820   return jresult;
3821 }
3822
3823
3824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3825   void * jresult ;
3826   Dali::Any *arg1 = (Dali::Any *) 0 ;
3827   std::type_info *result = 0 ;
3828
3829   arg1 = (Dali::Any *)jarg1;
3830   {
3831     try {
3832       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3833     } catch (std::out_of_range& e) {
3834       {
3835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3836       };
3837     } catch (std::exception& e) {
3838       {
3839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3840       };
3841     } catch (Dali::DaliException e) {
3842       {
3843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3844       };
3845     } catch (...) {
3846       {
3847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3848       };
3849     }
3850   }
3851
3852   jresult = (void *)result;
3853   return jresult;
3854 }
3855
3856
3857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3858   unsigned int jresult ;
3859   Dali::Any *arg1 = (Dali::Any *) 0 ;
3860   bool result;
3861
3862   arg1 = (Dali::Any *)jarg1;
3863   {
3864     try {
3865       result = (bool)((Dali::Any const *)arg1)->Empty();
3866     } catch (std::out_of_range& e) {
3867       {
3868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3869       };
3870     } catch (std::exception& e) {
3871       {
3872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3873       };
3874     } catch (Dali::DaliException e) {
3875       {
3876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3877       };
3878     } catch (...) {
3879       {
3880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3881       };
3882     }
3883   }
3884
3885   jresult = result;
3886   return jresult;
3887 }
3888
3889
3890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3891   void * jresult ;
3892   std::type_info *arg1 = 0 ;
3893   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3894   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3895   Dali::Any::AnyContainerBase *result = 0 ;
3896
3897   arg1 = (std::type_info *)jarg1;
3898   if (!arg1) {
3899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3900     return 0;
3901   }
3902   arg2 = (Dali::Any::CloneFunc)jarg2;
3903   arg3 = (Dali::Any::DeleteFunc)jarg3;
3904   {
3905     try {
3906       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3907     } catch (std::out_of_range& e) {
3908       {
3909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3910       };
3911     } catch (std::exception& e) {
3912       {
3913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3914       };
3915     } catch (Dali::DaliException e) {
3916       {
3917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3918       };
3919     } catch (...) {
3920       {
3921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3922       };
3923     }
3924   }
3925
3926   jresult = (void *)result;
3927   return jresult;
3928 }
3929
3930
3931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3932   void * jresult ;
3933   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3934   std::type_info *result = 0 ;
3935
3936   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3937   {
3938     try {
3939       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3940     } catch (std::out_of_range& e) {
3941       {
3942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3943       };
3944     } catch (std::exception& e) {
3945       {
3946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3947       };
3948     } catch (Dali::DaliException e) {
3949       {
3950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3951       };
3952     } catch (...) {
3953       {
3954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3955       };
3956     }
3957   }
3958
3959   jresult = (void *)result;
3960   return jresult;
3961 }
3962
3963
3964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3965   void * jresult ;
3966   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3967   ::std::type_info *result = 0 ;
3968
3969   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3970   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3971   jresult = (void *)result;
3972   return jresult;
3973 }
3974
3975
3976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3977   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3978   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3979
3980   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3981   arg2 = (Dali::Any::CloneFunc)jarg2;
3982   if (arg1) (arg1)->mCloneFunc = arg2;
3983 }
3984
3985
3986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3987   void * jresult ;
3988   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3989   Dali::Any::CloneFunc result;
3990
3991   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3992   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3993   jresult = (void *)result;
3994   return jresult;
3995 }
3996
3997
3998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3999   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4000   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4001
4002   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4003   arg2 = (Dali::Any::DeleteFunc)jarg2;
4004   if (arg1) (arg1)->mDeleteFunc = arg2;
4005 }
4006
4007
4008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4009   void * jresult ;
4010   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4011   Dali::Any::DeleteFunc result;
4012
4013   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4014   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4015   jresult = (void *)result;
4016   return jresult;
4017 }
4018
4019
4020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4021   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4022
4023   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4024   {
4025     try {
4026       delete arg1;
4027     } catch (std::out_of_range& e) {
4028       {
4029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4030       };
4031     } catch (std::exception& e) {
4032       {
4033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4034       };
4035     } catch (Dali::DaliException e) {
4036       {
4037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4038       };
4039     } catch (...) {
4040       {
4041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4042       };
4043     }
4044   }
4045
4046 }
4047
4048
4049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4050   Dali::Any *arg1 = (Dali::Any *) 0 ;
4051   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4052
4053   arg1 = (Dali::Any *)jarg1;
4054   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4055   if (arg1) (arg1)->mContainer = arg2;
4056 }
4057
4058
4059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4060   void * jresult ;
4061   Dali::Any *arg1 = (Dali::Any *) 0 ;
4062   Dali::Any::AnyContainerBase *result = 0 ;
4063
4064   arg1 = (Dali::Any *)jarg1;
4065   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4066   jresult = (void *)result;
4067   return jresult;
4068 }
4069
4070
4071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4072   char *arg1 = (char *) 0 ;
4073   char *arg2 = (char *) 0 ;
4074
4075   arg1 = (char *)jarg1;
4076   arg2 = (char *)jarg2;
4077   {
4078     try {
4079       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4080     } catch (std::out_of_range& e) {
4081       {
4082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4083       };
4084     } catch (std::exception& e) {
4085       {
4086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4087       };
4088     } catch (Dali::DaliException e) {
4089       {
4090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4091       };
4092     } catch (...) {
4093       {
4094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4095       };
4096     }
4097   }
4098
4099 }
4100
4101
4102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4103   void * jresult ;
4104   char *arg1 = (char *) 0 ;
4105   char *arg2 = (char *) 0 ;
4106   Dali::DaliException *result = 0 ;
4107
4108   arg1 = (char *)jarg1;
4109   arg2 = (char *)jarg2;
4110   {
4111     try {
4112       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4113     } catch (std::out_of_range& e) {
4114       {
4115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4116       };
4117     } catch (std::exception& e) {
4118       {
4119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4120       };
4121     } catch (Dali::DaliException e) {
4122       {
4123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4124       };
4125     } catch (...) {
4126       {
4127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4128       };
4129     }
4130   }
4131
4132   jresult = (void *)result;
4133   return jresult;
4134 }
4135
4136
4137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4138   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4139   std::string arg2 = std::string(jarg2);
4140
4141   arg1 = (Dali::DaliException *)jarg1;
4142   {
4143     if (!arg2.empty()) {
4144       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4145     } else {
4146       arg1->location = 0;
4147     }
4148   }
4149 }
4150
4151 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4152   char * jresult ;
4153   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4154   char *result = 0 ;
4155
4156   arg1 = (Dali::DaliException *)jarg1;
4157   result = (char *) ((arg1)->location);
4158   jresult = SWIG_csharp_string_callback((const char *)result);
4159   return jresult;
4160 }
4161
4162
4163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4164   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4165   std::string arg2 = std::string(jarg2);
4166
4167   arg1 = (Dali::DaliException *)jarg1;
4168   {
4169     if (!arg2.empty()) {
4170       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4171     } else {
4172       arg1->condition = 0;
4173     }
4174   }
4175 }
4176
4177
4178 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4179   char * jresult ;
4180   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4181   char *result = 0 ;
4182
4183   arg1 = (Dali::DaliException *)jarg1;
4184   result = (char *) ((arg1)->condition);
4185   jresult = SWIG_csharp_string_callback((const char *)result);
4186   return jresult;
4187 }
4188
4189
4190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4191   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4192
4193   arg1 = (Dali::DaliException *)jarg1;
4194   {
4195     try {
4196       delete arg1;
4197     } catch (std::out_of_range& e) {
4198       {
4199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4200       };
4201     } catch (std::exception& e) {
4202       {
4203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4204       };
4205     } catch (Dali::DaliException e) {
4206       {
4207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4208       };
4209     } catch (...) {
4210       {
4211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4212       };
4213     }
4214   }
4215
4216 }
4217
4218
4219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4220   void * jresult ;
4221   Dali::Vector2 *result = 0 ;
4222
4223   {
4224     try {
4225       result = (Dali::Vector2 *)new Dali::Vector2();
4226     } catch (std::out_of_range& e) {
4227       {
4228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4229       };
4230     } catch (std::exception& e) {
4231       {
4232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4233       };
4234     } catch (Dali::DaliException e) {
4235       {
4236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4237       };
4238     } catch (...) {
4239       {
4240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4241       };
4242     }
4243   }
4244
4245   jresult = (void *)result;
4246   return jresult;
4247 }
4248
4249
4250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4251   void * jresult ;
4252   float arg1 ;
4253   float arg2 ;
4254   Dali::Vector2 *result = 0 ;
4255
4256   arg1 = (float)jarg1;
4257   arg2 = (float)jarg2;
4258   {
4259     try {
4260       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4261     } catch (std::out_of_range& e) {
4262       {
4263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4264       };
4265     } catch (std::exception& e) {
4266       {
4267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4268       };
4269     } catch (Dali::DaliException e) {
4270       {
4271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4272       };
4273     } catch (...) {
4274       {
4275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4276       };
4277     }
4278   }
4279
4280   jresult = (void *)result;
4281   return jresult;
4282 }
4283
4284
4285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4286   void * jresult ;
4287   float *arg1 = (float *) 0 ;
4288   Dali::Vector2 *result = 0 ;
4289
4290   arg1 = jarg1;
4291   {
4292     try {
4293       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4294     } catch (std::out_of_range& e) {
4295       {
4296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4297       };
4298     } catch (std::exception& e) {
4299       {
4300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4301       };
4302     } catch (Dali::DaliException e) {
4303       {
4304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4305       };
4306     } catch (...) {
4307       {
4308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4309       };
4310     }
4311   }
4312
4313   jresult = (void *)result;
4314
4315
4316   return jresult;
4317 }
4318
4319
4320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4321   void * jresult ;
4322   Dali::Vector3 *arg1 = 0 ;
4323   Dali::Vector2 *result = 0 ;
4324
4325   arg1 = (Dali::Vector3 *)jarg1;
4326   if (!arg1) {
4327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4328     return 0;
4329   }
4330   {
4331     try {
4332       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4333     } catch (std::out_of_range& e) {
4334       {
4335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4336       };
4337     } catch (std::exception& e) {
4338       {
4339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4340       };
4341     } catch (Dali::DaliException e) {
4342       {
4343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4344       };
4345     } catch (...) {
4346       {
4347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4348       };
4349     }
4350   }
4351
4352   jresult = (void *)result;
4353   return jresult;
4354 }
4355
4356
4357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4358   void * jresult ;
4359   Dali::Vector4 *arg1 = 0 ;
4360   Dali::Vector2 *result = 0 ;
4361
4362   arg1 = (Dali::Vector4 *)jarg1;
4363   if (!arg1) {
4364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4365     return 0;
4366   }
4367   {
4368     try {
4369       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4370     } catch (std::out_of_range& e) {
4371       {
4372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4373       };
4374     } catch (std::exception& e) {
4375       {
4376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4377       };
4378     } catch (Dali::DaliException e) {
4379       {
4380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4381       };
4382     } catch (...) {
4383       {
4384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4385       };
4386     }
4387   }
4388
4389   jresult = (void *)result;
4390   return jresult;
4391 }
4392
4393
4394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4395   void * jresult ;
4396   Dali::Vector2 *result = 0 ;
4397
4398   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4399   jresult = (void *)result;
4400   return jresult;
4401 }
4402
4403
4404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4405   void * jresult ;
4406   Dali::Vector2 *result = 0 ;
4407
4408   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4409   jresult = (void *)result;
4410   return jresult;
4411 }
4412
4413
4414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4415   void * jresult ;
4416   Dali::Vector2 *result = 0 ;
4417
4418   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4419   jresult = (void *)result;
4420   return jresult;
4421 }
4422
4423
4424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4425   void * jresult ;
4426   Dali::Vector2 *result = 0 ;
4427
4428   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4429   jresult = (void *)result;
4430   return jresult;
4431 }
4432
4433
4434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4435   void * jresult ;
4436   Dali::Vector2 *result = 0 ;
4437
4438   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4439   jresult = (void *)result;
4440   return jresult;
4441 }
4442
4443
4444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4445   void * jresult ;
4446   Dali::Vector2 *result = 0 ;
4447
4448   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4449   jresult = (void *)result;
4450   return jresult;
4451 }
4452
4453
4454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4455   void * jresult ;
4456   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4457   float *arg2 = (float *) 0 ;
4458   Dali::Vector2 *result = 0 ;
4459
4460   arg1 = (Dali::Vector2 *)jarg1;
4461   arg2 = jarg2;
4462   {
4463     try {
4464       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4465     } catch (std::out_of_range& e) {
4466       {
4467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4468       };
4469     } catch (std::exception& e) {
4470       {
4471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4472       };
4473     } catch (Dali::DaliException e) {
4474       {
4475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4476       };
4477     } catch (...) {
4478       {
4479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4480       };
4481     }
4482   }
4483
4484   jresult = (void *)result;
4485
4486
4487   return jresult;
4488 }
4489
4490
4491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4492   void * jresult ;
4493   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4494   Dali::Vector3 *arg2 = 0 ;
4495   Dali::Vector2 *result = 0 ;
4496
4497   arg1 = (Dali::Vector2 *)jarg1;
4498   arg2 = (Dali::Vector3 *)jarg2;
4499   if (!arg2) {
4500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4501     return 0;
4502   }
4503   {
4504     try {
4505       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4506     } catch (std::out_of_range& e) {
4507       {
4508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4509       };
4510     } catch (std::exception& e) {
4511       {
4512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4513       };
4514     } catch (Dali::DaliException e) {
4515       {
4516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4517       };
4518     } catch (...) {
4519       {
4520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4521       };
4522     }
4523   }
4524
4525   jresult = (void *)result;
4526   return jresult;
4527 }
4528
4529
4530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4531   void * jresult ;
4532   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4533   Dali::Vector4 *arg2 = 0 ;
4534   Dali::Vector2 *result = 0 ;
4535
4536   arg1 = (Dali::Vector2 *)jarg1;
4537   arg2 = (Dali::Vector4 *)jarg2;
4538   if (!arg2) {
4539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4540     return 0;
4541   }
4542   {
4543     try {
4544       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4545     } catch (std::out_of_range& e) {
4546       {
4547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4548       };
4549     } catch (std::exception& e) {
4550       {
4551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4552       };
4553     } catch (Dali::DaliException e) {
4554       {
4555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4556       };
4557     } catch (...) {
4558       {
4559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4560       };
4561     }
4562   }
4563
4564   jresult = (void *)result;
4565   return jresult;
4566 }
4567
4568
4569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4570   void * jresult ;
4571   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4572   Dali::Vector2 *arg2 = 0 ;
4573   Dali::Vector2 result;
4574
4575   arg1 = (Dali::Vector2 *)jarg1;
4576   arg2 = (Dali::Vector2 *)jarg2;
4577   if (!arg2) {
4578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4579     return 0;
4580   }
4581   {
4582     try {
4583       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4584     } catch (std::out_of_range& e) {
4585       {
4586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4587       };
4588     } catch (std::exception& e) {
4589       {
4590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4591       };
4592     } catch (Dali::DaliException e) {
4593       {
4594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4595       };
4596     } catch (...) {
4597       {
4598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4599       };
4600     }
4601   }
4602
4603   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4604   return jresult;
4605 }
4606
4607
4608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4609   void * jresult ;
4610   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4611   Dali::Vector2 *arg2 = 0 ;
4612   Dali::Vector2 *result = 0 ;
4613
4614   arg1 = (Dali::Vector2 *)jarg1;
4615   arg2 = (Dali::Vector2 *)jarg2;
4616   if (!arg2) {
4617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4618     return 0;
4619   }
4620   {
4621     try {
4622       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
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 (Dali::DaliException e) {
4632       {
4633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4634       };
4635     } catch (...) {
4636       {
4637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4638       };
4639     }
4640   }
4641
4642   jresult = (void *)result;
4643   return jresult;
4644 }
4645
4646
4647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4648   void * jresult ;
4649   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4650   Dali::Vector2 *arg2 = 0 ;
4651   Dali::Vector2 result;
4652
4653   arg1 = (Dali::Vector2 *)jarg1;
4654   arg2 = (Dali::Vector2 *)jarg2;
4655   if (!arg2) {
4656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4657     return 0;
4658   }
4659   {
4660     try {
4661       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4662     } catch (std::out_of_range& e) {
4663       {
4664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4665       };
4666     } catch (std::exception& e) {
4667       {
4668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4669       };
4670     } catch (Dali::DaliException e) {
4671       {
4672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4673       };
4674     } catch (...) {
4675       {
4676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4677       };
4678     }
4679   }
4680
4681   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4682   return jresult;
4683 }
4684
4685
4686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4687   void * jresult ;
4688   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4689   Dali::Vector2 *arg2 = 0 ;
4690   Dali::Vector2 *result = 0 ;
4691
4692   arg1 = (Dali::Vector2 *)jarg1;
4693   arg2 = (Dali::Vector2 *)jarg2;
4694   if (!arg2) {
4695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4696     return 0;
4697   }
4698   {
4699     try {
4700       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4701     } catch (std::out_of_range& e) {
4702       {
4703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4704       };
4705     } catch (std::exception& e) {
4706       {
4707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4708       };
4709     } catch (Dali::DaliException e) {
4710       {
4711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4712       };
4713     } catch (...) {
4714       {
4715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4716       };
4717     }
4718   }
4719
4720   jresult = (void *)result;
4721   return jresult;
4722 }
4723
4724
4725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4726   void * jresult ;
4727   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4728   Dali::Vector2 *arg2 = 0 ;
4729   Dali::Vector2 result;
4730
4731   arg1 = (Dali::Vector2 *)jarg1;
4732   arg2 = (Dali::Vector2 *)jarg2;
4733   if (!arg2) {
4734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4735     return 0;
4736   }
4737   {
4738     try {
4739       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4740     } catch (std::out_of_range& e) {
4741       {
4742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4743       };
4744     } catch (std::exception& e) {
4745       {
4746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4747       };
4748     } catch (Dali::DaliException e) {
4749       {
4750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4751       };
4752     } catch (...) {
4753       {
4754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4755       };
4756     }
4757   }
4758
4759   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4760   return jresult;
4761 }
4762
4763
4764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4765   void * jresult ;
4766   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4767   float arg2 ;
4768   Dali::Vector2 result;
4769
4770   arg1 = (Dali::Vector2 *)jarg1;
4771   arg2 = (float)jarg2;
4772   {
4773     try {
4774       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4775     } catch (std::out_of_range& e) {
4776       {
4777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4778       };
4779     } catch (std::exception& e) {
4780       {
4781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4782       };
4783     } catch (Dali::DaliException e) {
4784       {
4785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4786       };
4787     } catch (...) {
4788       {
4789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4790       };
4791     }
4792   }
4793
4794   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4795   return jresult;
4796 }
4797
4798
4799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4800   void * jresult ;
4801   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4802   Dali::Vector2 *arg2 = 0 ;
4803   Dali::Vector2 *result = 0 ;
4804
4805   arg1 = (Dali::Vector2 *)jarg1;
4806   arg2 = (Dali::Vector2 *)jarg2;
4807   if (!arg2) {
4808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4809     return 0;
4810   }
4811   {
4812     try {
4813       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4814     } catch (std::out_of_range& e) {
4815       {
4816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4817       };
4818     } catch (std::exception& e) {
4819       {
4820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4821       };
4822     } catch (Dali::DaliException e) {
4823       {
4824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4825       };
4826     } catch (...) {
4827       {
4828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4829       };
4830     }
4831   }
4832
4833   jresult = (void *)result;
4834   return jresult;
4835 }
4836
4837
4838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4839   void * jresult ;
4840   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4841   float arg2 ;
4842   Dali::Vector2 *result = 0 ;
4843
4844   arg1 = (Dali::Vector2 *)jarg1;
4845   arg2 = (float)jarg2;
4846   {
4847     try {
4848       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4849     } catch (std::out_of_range& e) {
4850       {
4851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4852       };
4853     } catch (std::exception& e) {
4854       {
4855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4856       };
4857     } catch (Dali::DaliException e) {
4858       {
4859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4860       };
4861     } catch (...) {
4862       {
4863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4864       };
4865     }
4866   }
4867
4868   jresult = (void *)result;
4869   return jresult;
4870 }
4871
4872
4873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4874   void * jresult ;
4875   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4876   Dali::Vector2 *arg2 = 0 ;
4877   Dali::Vector2 result;
4878
4879   arg1 = (Dali::Vector2 *)jarg1;
4880   arg2 = (Dali::Vector2 *)jarg2;
4881   if (!arg2) {
4882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4883     return 0;
4884   }
4885   {
4886     try {
4887       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4888     } catch (std::out_of_range& e) {
4889       {
4890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4891       };
4892     } catch (std::exception& e) {
4893       {
4894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4895       };
4896     } catch (Dali::DaliException e) {
4897       {
4898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4899       };
4900     } catch (...) {
4901       {
4902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4903       };
4904     }
4905   }
4906
4907   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4908   return jresult;
4909 }
4910
4911
4912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4913   void * jresult ;
4914   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4915   float arg2 ;
4916   Dali::Vector2 result;
4917
4918   arg1 = (Dali::Vector2 *)jarg1;
4919   arg2 = (float)jarg2;
4920   {
4921     try {
4922       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4923     } catch (std::out_of_range& e) {
4924       {
4925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4926       };
4927     } catch (std::exception& e) {
4928       {
4929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4930       };
4931     } catch (Dali::DaliException e) {
4932       {
4933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4934       };
4935     } catch (...) {
4936       {
4937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4938       };
4939     }
4940   }
4941
4942   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4943   return jresult;
4944 }
4945
4946
4947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4948   void * jresult ;
4949   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4950   Dali::Vector2 *arg2 = 0 ;
4951   Dali::Vector2 *result = 0 ;
4952
4953   arg1 = (Dali::Vector2 *)jarg1;
4954   arg2 = (Dali::Vector2 *)jarg2;
4955   if (!arg2) {
4956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4957     return 0;
4958   }
4959   {
4960     try {
4961       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4962     } catch (std::out_of_range& e) {
4963       {
4964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4965       };
4966     } catch (std::exception& e) {
4967       {
4968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4969       };
4970     } catch (Dali::DaliException e) {
4971       {
4972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4973       };
4974     } catch (...) {
4975       {
4976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4977       };
4978     }
4979   }
4980
4981   jresult = (void *)result;
4982   return jresult;
4983 }
4984
4985
4986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4987   void * jresult ;
4988   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4989   float arg2 ;
4990   Dali::Vector2 *result = 0 ;
4991
4992   arg1 = (Dali::Vector2 *)jarg1;
4993   arg2 = (float)jarg2;
4994   {
4995     try {
4996       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4997     } catch (std::out_of_range& e) {
4998       {
4999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5000       };
5001     } catch (std::exception& e) {
5002       {
5003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5004       };
5005     } catch (Dali::DaliException e) {
5006       {
5007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5008       };
5009     } catch (...) {
5010       {
5011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5012       };
5013     }
5014   }
5015
5016   jresult = (void *)result;
5017   return jresult;
5018 }
5019
5020
5021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5022   void * jresult ;
5023   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5024   Dali::Vector2 result;
5025
5026   arg1 = (Dali::Vector2 *)jarg1;
5027   {
5028     try {
5029       result = ((Dali::Vector2 const *)arg1)->operator -();
5030     } catch (std::out_of_range& e) {
5031       {
5032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5033       };
5034     } catch (std::exception& e) {
5035       {
5036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5037       };
5038     } catch (Dali::DaliException e) {
5039       {
5040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5041       };
5042     } catch (...) {
5043       {
5044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5045       };
5046     }
5047   }
5048
5049   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5050   return jresult;
5051 }
5052
5053
5054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5055   unsigned int jresult ;
5056   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5057   Dali::Vector2 *arg2 = 0 ;
5058   bool result;
5059
5060   arg1 = (Dali::Vector2 *)jarg1;
5061   arg2 = (Dali::Vector2 *)jarg2;
5062   if (!arg2) {
5063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5064     return 0;
5065   }
5066   {
5067     try {
5068       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5069     } catch (std::out_of_range& e) {
5070       {
5071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5072       };
5073     } catch (std::exception& e) {
5074       {
5075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5076       };
5077     } catch (Dali::DaliException e) {
5078       {
5079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5080       };
5081     } catch (...) {
5082       {
5083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5084       };
5085     }
5086   }
5087
5088   jresult = result;
5089   return jresult;
5090 }
5091
5092
5093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5094   unsigned int jresult ;
5095   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5096   Dali::Vector2 *arg2 = 0 ;
5097   bool result;
5098
5099   arg1 = (Dali::Vector2 *)jarg1;
5100   arg2 = (Dali::Vector2 *)jarg2;
5101   if (!arg2) {
5102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5103     return 0;
5104   }
5105   {
5106     try {
5107       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5108     } catch (std::out_of_range& e) {
5109       {
5110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5111       };
5112     } catch (std::exception& e) {
5113       {
5114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5115       };
5116     } catch (Dali::DaliException e) {
5117       {
5118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5119       };
5120     } catch (...) {
5121       {
5122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5123       };
5124     }
5125   }
5126
5127   jresult = result;
5128   return jresult;
5129 }
5130
5131
5132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5133   float jresult ;
5134   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5135   unsigned int arg2 ;
5136   float *result = 0 ;
5137
5138   arg1 = (Dali::Vector2 *)jarg1;
5139   arg2 = (unsigned int)jarg2;
5140   {
5141     try {
5142       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5143     } catch (std::out_of_range& e) {
5144       {
5145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5146       };
5147     } catch (std::exception& e) {
5148       {
5149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5150       };
5151     } catch (Dali::DaliException e) {
5152       {
5153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5154       };
5155     } catch (...) {
5156       {
5157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5158       };
5159     }
5160   }
5161
5162   jresult = *result;
5163   return jresult;
5164 }
5165
5166
5167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5168   float jresult ;
5169   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5170   float result;
5171
5172   arg1 = (Dali::Vector2 *)jarg1;
5173   {
5174     try {
5175       result = (float)((Dali::Vector2 const *)arg1)->Length();
5176     } catch (std::out_of_range& e) {
5177       {
5178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5179       };
5180     } catch (std::exception& e) {
5181       {
5182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5183       };
5184     } catch (Dali::DaliException e) {
5185       {
5186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5187       };
5188     } catch (...) {
5189       {
5190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5191       };
5192     }
5193   }
5194
5195   jresult = result;
5196   return jresult;
5197 }
5198
5199
5200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5201   float jresult ;
5202   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5203   float result;
5204
5205   arg1 = (Dali::Vector2 *)jarg1;
5206   {
5207     try {
5208       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5209     } catch (std::out_of_range& e) {
5210       {
5211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5212       };
5213     } catch (std::exception& e) {
5214       {
5215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5216       };
5217     } catch (Dali::DaliException e) {
5218       {
5219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5220       };
5221     } catch (...) {
5222       {
5223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5224       };
5225     }
5226   }
5227
5228   jresult = result;
5229   return jresult;
5230 }
5231
5232
5233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5234   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5235
5236   arg1 = (Dali::Vector2 *)jarg1;
5237   {
5238     try {
5239       (arg1)->Normalize();
5240     } catch (std::out_of_range& e) {
5241       {
5242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5243       };
5244     } catch (std::exception& e) {
5245       {
5246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5247       };
5248     } catch (Dali::DaliException e) {
5249       {
5250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5251       };
5252     } catch (...) {
5253       {
5254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5255       };
5256     }
5257   }
5258
5259 }
5260
5261
5262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5263   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5264   Dali::Vector2 *arg2 = 0 ;
5265   Dali::Vector2 *arg3 = 0 ;
5266
5267   arg1 = (Dali::Vector2 *)jarg1;
5268   arg2 = (Dali::Vector2 *)jarg2;
5269   if (!arg2) {
5270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5271     return ;
5272   }
5273   arg3 = (Dali::Vector2 *)jarg3;
5274   if (!arg3) {
5275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5276     return ;
5277   }
5278   {
5279     try {
5280       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5281     } catch (std::out_of_range& e) {
5282       {
5283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5284       };
5285     } catch (std::exception& e) {
5286       {
5287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5288       };
5289     } catch (Dali::DaliException e) {
5290       {
5291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5292       };
5293     } catch (...) {
5294       {
5295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5296       };
5297     }
5298   }
5299
5300 }
5301
5302
5303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5304   void * jresult ;
5305   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5306   float *result = 0 ;
5307
5308   arg1 = (Dali::Vector2 *)jarg1;
5309   {
5310     try {
5311       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5312     } catch (std::out_of_range& e) {
5313       {
5314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5315       };
5316     } catch (std::exception& e) {
5317       {
5318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5319       };
5320     } catch (Dali::DaliException e) {
5321       {
5322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5323       };
5324     } catch (...) {
5325       {
5326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5327       };
5328     }
5329   }
5330
5331   jresult = (void *)result;
5332   return jresult;
5333 }
5334
5335
5336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5337   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5338   float arg2 ;
5339
5340   arg1 = (Dali::Vector2 *)jarg1;
5341   arg2 = (float)jarg2;
5342   if (arg1) (arg1)->x = arg2;
5343 }
5344
5345
5346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5347   float jresult ;
5348   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5349   float result;
5350
5351   arg1 = (Dali::Vector2 *)jarg1;
5352   result = (float) ((arg1)->x);
5353   jresult = result;
5354   return jresult;
5355 }
5356
5357
5358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5359   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5360   float arg2 ;
5361
5362   arg1 = (Dali::Vector2 *)jarg1;
5363   arg2 = (float)jarg2;
5364   if (arg1) (arg1)->width = arg2;
5365 }
5366
5367
5368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5369   float jresult ;
5370   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5371   float result;
5372
5373   arg1 = (Dali::Vector2 *)jarg1;
5374   result = (float) ((arg1)->width);
5375   jresult = result;
5376   return jresult;
5377 }
5378
5379
5380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5381   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5382   float arg2 ;
5383
5384   arg1 = (Dali::Vector2 *)jarg1;
5385   arg2 = (float)jarg2;
5386   if (arg1) (arg1)->y = arg2;
5387 }
5388
5389
5390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5391   float jresult ;
5392   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5393   float result;
5394
5395   arg1 = (Dali::Vector2 *)jarg1;
5396   result = (float) ((arg1)->y);
5397   jresult = result;
5398   return jresult;
5399 }
5400
5401
5402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5403   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5404   float arg2 ;
5405
5406   arg1 = (Dali::Vector2 *)jarg1;
5407   arg2 = (float)jarg2;
5408   if (arg1) (arg1)->height = arg2;
5409 }
5410
5411
5412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5413   float jresult ;
5414   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5415   float result;
5416
5417   arg1 = (Dali::Vector2 *)jarg1;
5418   result = (float) ((arg1)->height);
5419   jresult = result;
5420   return jresult;
5421 }
5422
5423
5424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5425   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5426
5427   arg1 = (Dali::Vector2 *)jarg1;
5428   {
5429     try {
5430       delete arg1;
5431     } catch (std::out_of_range& e) {
5432       {
5433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5434       };
5435     } catch (std::exception& e) {
5436       {
5437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5438       };
5439     } catch (Dali::DaliException e) {
5440       {
5441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5442       };
5443     } catch (...) {
5444       {
5445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5446       };
5447     }
5448   }
5449
5450 }
5451
5452
5453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5454   void * jresult ;
5455   Dali::Vector2 *arg1 = 0 ;
5456   Dali::Vector2 *arg2 = 0 ;
5457   Dali::Vector2 result;
5458
5459   arg1 = (Dali::Vector2 *)jarg1;
5460   if (!arg1) {
5461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5462     return 0;
5463   }
5464   arg2 = (Dali::Vector2 *)jarg2;
5465   if (!arg2) {
5466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5467     return 0;
5468   }
5469   {
5470     try {
5471       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5472     } catch (std::out_of_range& e) {
5473       {
5474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5475       };
5476     } catch (std::exception& e) {
5477       {
5478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5479       };
5480     } catch (Dali::DaliException e) {
5481       {
5482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5483       };
5484     } catch (...) {
5485       {
5486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5487       };
5488     }
5489   }
5490
5491   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5492   return jresult;
5493 }
5494
5495
5496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5497   void * jresult ;
5498   Dali::Vector2 *arg1 = 0 ;
5499   Dali::Vector2 *arg2 = 0 ;
5500   Dali::Vector2 result;
5501
5502   arg1 = (Dali::Vector2 *)jarg1;
5503   if (!arg1) {
5504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5505     return 0;
5506   }
5507   arg2 = (Dali::Vector2 *)jarg2;
5508   if (!arg2) {
5509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5510     return 0;
5511   }
5512   {
5513     try {
5514       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5515     } catch (std::out_of_range& e) {
5516       {
5517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5518       };
5519     } catch (std::exception& e) {
5520       {
5521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5522       };
5523     } catch (Dali::DaliException e) {
5524       {
5525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5526       };
5527     } catch (...) {
5528       {
5529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5530       };
5531     }
5532   }
5533
5534   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5535   return jresult;
5536 }
5537
5538
5539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5540   void * jresult ;
5541   Dali::Vector2 *arg1 = 0 ;
5542   float *arg2 = 0 ;
5543   float *arg3 = 0 ;
5544   float temp2 ;
5545   float temp3 ;
5546   Dali::Vector2 result;
5547
5548   arg1 = (Dali::Vector2 *)jarg1;
5549   if (!arg1) {
5550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5551     return 0;
5552   }
5553   temp2 = (float)jarg2;
5554   arg2 = &temp2;
5555   temp3 = (float)jarg3;
5556   arg3 = &temp3;
5557   {
5558     try {
5559       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5560     } catch (std::out_of_range& e) {
5561       {
5562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5563       };
5564     } catch (std::exception& e) {
5565       {
5566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5567       };
5568     } catch (Dali::DaliException e) {
5569       {
5570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5571       };
5572     } catch (...) {
5573       {
5574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5575       };
5576     }
5577   }
5578
5579   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5580   return jresult;
5581 }
5582
5583
5584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5585   void * jresult ;
5586   Dali::Vector3 *result = 0 ;
5587
5588   {
5589     try {
5590       result = (Dali::Vector3 *)new Dali::Vector3();
5591     } catch (std::out_of_range& e) {
5592       {
5593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5594       };
5595     } catch (std::exception& e) {
5596       {
5597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5598       };
5599     } catch (Dali::DaliException e) {
5600       {
5601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5602       };
5603     } catch (...) {
5604       {
5605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5606       };
5607     }
5608   }
5609
5610   jresult = (void *)result;
5611   return jresult;
5612 }
5613
5614
5615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5616   void * jresult ;
5617   float arg1 ;
5618   float arg2 ;
5619   float arg3 ;
5620   Dali::Vector3 *result = 0 ;
5621
5622   arg1 = (float)jarg1;
5623   arg2 = (float)jarg2;
5624   arg3 = (float)jarg3;
5625   {
5626     try {
5627       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5628     } catch (std::out_of_range& e) {
5629       {
5630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5631       };
5632     } catch (std::exception& e) {
5633       {
5634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5635       };
5636     } catch (Dali::DaliException e) {
5637       {
5638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5639       };
5640     } catch (...) {
5641       {
5642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5643       };
5644     }
5645   }
5646
5647   jresult = (void *)result;
5648   return jresult;
5649 }
5650
5651
5652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5653   void * jresult ;
5654   float *arg1 = (float *) 0 ;
5655   Dali::Vector3 *result = 0 ;
5656
5657   arg1 = jarg1;
5658   {
5659     try {
5660       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
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 (Dali::DaliException e) {
5670       {
5671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5672       };
5673     } catch (...) {
5674       {
5675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5676       };
5677     }
5678   }
5679
5680   jresult = (void *)result;
5681
5682
5683   return jresult;
5684 }
5685
5686
5687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5688   void * jresult ;
5689   Dali::Vector2 *arg1 = 0 ;
5690   Dali::Vector3 *result = 0 ;
5691
5692   arg1 = (Dali::Vector2 *)jarg1;
5693   if (!arg1) {
5694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5695     return 0;
5696   }
5697   {
5698     try {
5699       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5700     } catch (std::out_of_range& e) {
5701       {
5702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5703       };
5704     } catch (std::exception& e) {
5705       {
5706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5707       };
5708     } catch (Dali::DaliException e) {
5709       {
5710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5711       };
5712     } catch (...) {
5713       {
5714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5715       };
5716     }
5717   }
5718
5719   jresult = (void *)result;
5720   return jresult;
5721 }
5722
5723
5724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5725   void * jresult ;
5726   Dali::Vector4 *arg1 = 0 ;
5727   Dali::Vector3 *result = 0 ;
5728
5729   arg1 = (Dali::Vector4 *)jarg1;
5730   if (!arg1) {
5731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5732     return 0;
5733   }
5734   {
5735     try {
5736       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5737     } catch (std::out_of_range& e) {
5738       {
5739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5740       };
5741     } catch (std::exception& e) {
5742       {
5743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5744       };
5745     } catch (Dali::DaliException e) {
5746       {
5747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5748       };
5749     } catch (...) {
5750       {
5751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5752       };
5753     }
5754   }
5755
5756   jresult = (void *)result;
5757   return jresult;
5758 }
5759
5760
5761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5762   void * jresult ;
5763   Dali::Vector3 *result = 0 ;
5764
5765   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5766   jresult = (void *)result;
5767   return jresult;
5768 }
5769
5770
5771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5772   void * jresult ;
5773   Dali::Vector3 *result = 0 ;
5774
5775   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5776   jresult = (void *)result;
5777   return jresult;
5778 }
5779
5780
5781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5782   void * jresult ;
5783   Dali::Vector3 *result = 0 ;
5784
5785   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5786   jresult = (void *)result;
5787   return jresult;
5788 }
5789
5790
5791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5792   void * jresult ;
5793   Dali::Vector3 *result = 0 ;
5794
5795   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5796   jresult = (void *)result;
5797   return jresult;
5798 }
5799
5800
5801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5802   void * jresult ;
5803   Dali::Vector3 *result = 0 ;
5804
5805   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5806   jresult = (void *)result;
5807   return jresult;
5808 }
5809
5810
5811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5812   void * jresult ;
5813   Dali::Vector3 *result = 0 ;
5814
5815   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5816   jresult = (void *)result;
5817   return jresult;
5818 }
5819
5820
5821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5822   void * jresult ;
5823   Dali::Vector3 *result = 0 ;
5824
5825   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5826   jresult = (void *)result;
5827   return jresult;
5828 }
5829
5830
5831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5832   void * jresult ;
5833   Dali::Vector3 *result = 0 ;
5834
5835   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5836   jresult = (void *)result;
5837   return jresult;
5838 }
5839
5840
5841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5842   void * jresult ;
5843   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5844   float *arg2 = (float *) 0 ;
5845   Dali::Vector3 *result = 0 ;
5846
5847   arg1 = (Dali::Vector3 *)jarg1;
5848   arg2 = jarg2;
5849   {
5850     try {
5851       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5852     } catch (std::out_of_range& e) {
5853       {
5854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5855       };
5856     } catch (std::exception& e) {
5857       {
5858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5859       };
5860     } catch (Dali::DaliException e) {
5861       {
5862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5863       };
5864     } catch (...) {
5865       {
5866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5867       };
5868     }
5869   }
5870
5871   jresult = (void *)result;
5872
5873
5874   return jresult;
5875 }
5876
5877
5878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5879   void * jresult ;
5880   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5881   Dali::Vector2 *arg2 = 0 ;
5882   Dali::Vector3 *result = 0 ;
5883
5884   arg1 = (Dali::Vector3 *)jarg1;
5885   arg2 = (Dali::Vector2 *)jarg2;
5886   if (!arg2) {
5887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5888     return 0;
5889   }
5890   {
5891     try {
5892       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5893     } catch (std::out_of_range& e) {
5894       {
5895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5896       };
5897     } catch (std::exception& e) {
5898       {
5899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5900       };
5901     } catch (Dali::DaliException e) {
5902       {
5903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5904       };
5905     } catch (...) {
5906       {
5907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5908       };
5909     }
5910   }
5911
5912   jresult = (void *)result;
5913   return jresult;
5914 }
5915
5916
5917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5918   void * jresult ;
5919   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5920   Dali::Vector4 *arg2 = 0 ;
5921   Dali::Vector3 *result = 0 ;
5922
5923   arg1 = (Dali::Vector3 *)jarg1;
5924   arg2 = (Dali::Vector4 *)jarg2;
5925   if (!arg2) {
5926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5927     return 0;
5928   }
5929   {
5930     try {
5931       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5932     } catch (std::out_of_range& e) {
5933       {
5934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5935       };
5936     } catch (std::exception& e) {
5937       {
5938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5939       };
5940     } catch (Dali::DaliException e) {
5941       {
5942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5943       };
5944     } catch (...) {
5945       {
5946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5947       };
5948     }
5949   }
5950
5951   jresult = (void *)result;
5952   return jresult;
5953 }
5954
5955
5956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5957   void * jresult ;
5958   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5959   Dali::Vector3 *arg2 = 0 ;
5960   Dali::Vector3 result;
5961
5962   arg1 = (Dali::Vector3 *)jarg1;
5963   arg2 = (Dali::Vector3 *)jarg2;
5964   if (!arg2) {
5965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5966     return 0;
5967   }
5968   {
5969     try {
5970       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5971     } catch (std::out_of_range& e) {
5972       {
5973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5974       };
5975     } catch (std::exception& e) {
5976       {
5977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5978       };
5979     } catch (Dali::DaliException e) {
5980       {
5981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5982       };
5983     } catch (...) {
5984       {
5985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5986       };
5987     }
5988   }
5989
5990   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5991   return jresult;
5992 }
5993
5994
5995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5996   void * jresult ;
5997   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5998   Dali::Vector3 *arg2 = 0 ;
5999   Dali::Vector3 *result = 0 ;
6000
6001   arg1 = (Dali::Vector3 *)jarg1;
6002   arg2 = (Dali::Vector3 *)jarg2;
6003   if (!arg2) {
6004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6005     return 0;
6006   }
6007   {
6008     try {
6009       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6010     } catch (std::out_of_range& e) {
6011       {
6012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6013       };
6014     } catch (std::exception& e) {
6015       {
6016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6017       };
6018     } catch (Dali::DaliException e) {
6019       {
6020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6021       };
6022     } catch (...) {
6023       {
6024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6025       };
6026     }
6027   }
6028
6029   jresult = (void *)result;
6030   return jresult;
6031 }
6032
6033
6034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6035   void * jresult ;
6036   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6037   Dali::Vector3 *arg2 = 0 ;
6038   Dali::Vector3 result;
6039
6040   arg1 = (Dali::Vector3 *)jarg1;
6041   arg2 = (Dali::Vector3 *)jarg2;
6042   if (!arg2) {
6043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6044     return 0;
6045   }
6046   {
6047     try {
6048       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6049     } catch (std::out_of_range& e) {
6050       {
6051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6052       };
6053     } catch (std::exception& e) {
6054       {
6055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6056       };
6057     } catch (Dali::DaliException e) {
6058       {
6059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6060       };
6061     } catch (...) {
6062       {
6063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6064       };
6065     }
6066   }
6067
6068   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6069   return jresult;
6070 }
6071
6072
6073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6074   void * jresult ;
6075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6076   Dali::Vector3 *arg2 = 0 ;
6077   Dali::Vector3 *result = 0 ;
6078
6079   arg1 = (Dali::Vector3 *)jarg1;
6080   arg2 = (Dali::Vector3 *)jarg2;
6081   if (!arg2) {
6082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6083     return 0;
6084   }
6085   {
6086     try {
6087       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6088     } catch (std::out_of_range& e) {
6089       {
6090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6091       };
6092     } catch (std::exception& e) {
6093       {
6094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6095       };
6096     } catch (Dali::DaliException e) {
6097       {
6098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6099       };
6100     } catch (...) {
6101       {
6102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6103       };
6104     }
6105   }
6106
6107   jresult = (void *)result;
6108   return jresult;
6109 }
6110
6111
6112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6113   void * jresult ;
6114   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6115   Dali::Vector3 *arg2 = 0 ;
6116   Dali::Vector3 result;
6117
6118   arg1 = (Dali::Vector3 *)jarg1;
6119   arg2 = (Dali::Vector3 *)jarg2;
6120   if (!arg2) {
6121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6122     return 0;
6123   }
6124   {
6125     try {
6126       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6127     } catch (std::out_of_range& e) {
6128       {
6129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6130       };
6131     } catch (std::exception& e) {
6132       {
6133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6134       };
6135     } catch (Dali::DaliException e) {
6136       {
6137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6138       };
6139     } catch (...) {
6140       {
6141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6142       };
6143     }
6144   }
6145
6146   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6147   return jresult;
6148 }
6149
6150
6151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6152   void * jresult ;
6153   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6154   float arg2 ;
6155   Dali::Vector3 result;
6156
6157   arg1 = (Dali::Vector3 *)jarg1;
6158   arg2 = (float)jarg2;
6159   {
6160     try {
6161       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6162     } catch (std::out_of_range& e) {
6163       {
6164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6165       };
6166     } catch (std::exception& e) {
6167       {
6168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6169       };
6170     } catch (Dali::DaliException e) {
6171       {
6172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6173       };
6174     } catch (...) {
6175       {
6176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6177       };
6178     }
6179   }
6180
6181   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6182   return jresult;
6183 }
6184
6185
6186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6187   void * jresult ;
6188   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6189   Dali::Vector3 *arg2 = 0 ;
6190   Dali::Vector3 *result = 0 ;
6191
6192   arg1 = (Dali::Vector3 *)jarg1;
6193   arg2 = (Dali::Vector3 *)jarg2;
6194   if (!arg2) {
6195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6196     return 0;
6197   }
6198   {
6199     try {
6200       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6201     } catch (std::out_of_range& e) {
6202       {
6203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6204       };
6205     } catch (std::exception& e) {
6206       {
6207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6208       };
6209     } catch (Dali::DaliException e) {
6210       {
6211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6212       };
6213     } catch (...) {
6214       {
6215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6216       };
6217     }
6218   }
6219
6220   jresult = (void *)result;
6221   return jresult;
6222 }
6223
6224
6225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6226   void * jresult ;
6227   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6228   float arg2 ;
6229   Dali::Vector3 *result = 0 ;
6230
6231   arg1 = (Dali::Vector3 *)jarg1;
6232   arg2 = (float)jarg2;
6233   {
6234     try {
6235       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6236     } catch (std::out_of_range& e) {
6237       {
6238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6239       };
6240     } catch (std::exception& e) {
6241       {
6242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6243       };
6244     } catch (Dali::DaliException e) {
6245       {
6246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6247       };
6248     } catch (...) {
6249       {
6250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6251       };
6252     }
6253   }
6254
6255   jresult = (void *)result;
6256   return jresult;
6257 }
6258
6259
6260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6261   void * jresult ;
6262   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6263   Dali::Quaternion *arg2 = 0 ;
6264   Dali::Vector3 *result = 0 ;
6265
6266   arg1 = (Dali::Vector3 *)jarg1;
6267   arg2 = (Dali::Quaternion *)jarg2;
6268   if (!arg2) {
6269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6270     return 0;
6271   }
6272   {
6273     try {
6274       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6275     } catch (std::out_of_range& e) {
6276       {
6277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6278       };
6279     } catch (std::exception& e) {
6280       {
6281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6282       };
6283     } catch (Dali::DaliException e) {
6284       {
6285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6286       };
6287     } catch (...) {
6288       {
6289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6290       };
6291     }
6292   }
6293
6294   jresult = (void *)result;
6295   return jresult;
6296 }
6297
6298
6299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6300   void * jresult ;
6301   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6302   Dali::Vector3 *arg2 = 0 ;
6303   Dali::Vector3 result;
6304
6305   arg1 = (Dali::Vector3 *)jarg1;
6306   arg2 = (Dali::Vector3 *)jarg2;
6307   if (!arg2) {
6308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6309     return 0;
6310   }
6311   {
6312     try {
6313       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6314     } catch (std::out_of_range& e) {
6315       {
6316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6317       };
6318     } catch (std::exception& e) {
6319       {
6320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6321       };
6322     } catch (Dali::DaliException e) {
6323       {
6324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6325       };
6326     } catch (...) {
6327       {
6328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6329       };
6330     }
6331   }
6332
6333   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6334   return jresult;
6335 }
6336
6337
6338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6339   void * jresult ;
6340   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6341   float arg2 ;
6342   Dali::Vector3 result;
6343
6344   arg1 = (Dali::Vector3 *)jarg1;
6345   arg2 = (float)jarg2;
6346   {
6347     try {
6348       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6349     } catch (std::out_of_range& e) {
6350       {
6351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6352       };
6353     } catch (std::exception& e) {
6354       {
6355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6356       };
6357     } catch (Dali::DaliException e) {
6358       {
6359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6360       };
6361     } catch (...) {
6362       {
6363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6364       };
6365     }
6366   }
6367
6368   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6369   return jresult;
6370 }
6371
6372
6373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6374   void * jresult ;
6375   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6376   Dali::Vector3 *arg2 = 0 ;
6377   Dali::Vector3 *result = 0 ;
6378
6379   arg1 = (Dali::Vector3 *)jarg1;
6380   arg2 = (Dali::Vector3 *)jarg2;
6381   if (!arg2) {
6382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6383     return 0;
6384   }
6385   {
6386     try {
6387       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6388     } catch (std::out_of_range& e) {
6389       {
6390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6391       };
6392     } catch (std::exception& e) {
6393       {
6394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6395       };
6396     } catch (Dali::DaliException e) {
6397       {
6398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6399       };
6400     } catch (...) {
6401       {
6402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6403       };
6404     }
6405   }
6406
6407   jresult = (void *)result;
6408   return jresult;
6409 }
6410
6411
6412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6413   void * jresult ;
6414   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6415   float arg2 ;
6416   Dali::Vector3 *result = 0 ;
6417
6418   arg1 = (Dali::Vector3 *)jarg1;
6419   arg2 = (float)jarg2;
6420   {
6421     try {
6422       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6423     } catch (std::out_of_range& e) {
6424       {
6425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6426       };
6427     } catch (std::exception& e) {
6428       {
6429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6430       };
6431     } catch (Dali::DaliException e) {
6432       {
6433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6434       };
6435     } catch (...) {
6436       {
6437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6438       };
6439     }
6440   }
6441
6442   jresult = (void *)result;
6443   return jresult;
6444 }
6445
6446
6447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6448   void * jresult ;
6449   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6450   Dali::Vector3 result;
6451
6452   arg1 = (Dali::Vector3 *)jarg1;
6453   {
6454     try {
6455       result = ((Dali::Vector3 const *)arg1)->operator -();
6456     } catch (std::out_of_range& e) {
6457       {
6458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6459       };
6460     } catch (std::exception& e) {
6461       {
6462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6463       };
6464     } catch (Dali::DaliException e) {
6465       {
6466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6467       };
6468     } catch (...) {
6469       {
6470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6471       };
6472     }
6473   }
6474
6475   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6476   return jresult;
6477 }
6478
6479
6480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6481   unsigned int jresult ;
6482   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6483   Dali::Vector3 *arg2 = 0 ;
6484   bool result;
6485
6486   arg1 = (Dali::Vector3 *)jarg1;
6487   arg2 = (Dali::Vector3 *)jarg2;
6488   if (!arg2) {
6489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6490     return 0;
6491   }
6492   {
6493     try {
6494       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6495     } catch (std::out_of_range& e) {
6496       {
6497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6498       };
6499     } catch (std::exception& e) {
6500       {
6501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6502       };
6503     } catch (Dali::DaliException e) {
6504       {
6505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6506       };
6507     } catch (...) {
6508       {
6509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6510       };
6511     }
6512   }
6513
6514   jresult = result;
6515   return jresult;
6516 }
6517
6518
6519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6520   unsigned int jresult ;
6521   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6522   Dali::Vector3 *arg2 = 0 ;
6523   bool result;
6524
6525   arg1 = (Dali::Vector3 *)jarg1;
6526   arg2 = (Dali::Vector3 *)jarg2;
6527   if (!arg2) {
6528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6529     return 0;
6530   }
6531   {
6532     try {
6533       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6534     } catch (std::out_of_range& e) {
6535       {
6536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6537       };
6538     } catch (std::exception& e) {
6539       {
6540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6541       };
6542     } catch (Dali::DaliException e) {
6543       {
6544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6545       };
6546     } catch (...) {
6547       {
6548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6549       };
6550     }
6551   }
6552
6553   jresult = result;
6554   return jresult;
6555 }
6556
6557
6558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6559   float jresult ;
6560   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6561   unsigned int arg2 ;
6562   float *result = 0 ;
6563
6564   arg1 = (Dali::Vector3 *)jarg1;
6565   arg2 = (unsigned int)jarg2;
6566   {
6567     try {
6568       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6569     } catch (std::out_of_range& e) {
6570       {
6571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6572       };
6573     } catch (std::exception& e) {
6574       {
6575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6576       };
6577     } catch (Dali::DaliException e) {
6578       {
6579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6580       };
6581     } catch (...) {
6582       {
6583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6584       };
6585     }
6586   }
6587
6588   jresult = *result;
6589   return jresult;
6590 }
6591
6592
6593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6594   float jresult ;
6595   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6596   Dali::Vector3 *arg2 = 0 ;
6597   float result;
6598
6599   arg1 = (Dali::Vector3 *)jarg1;
6600   arg2 = (Dali::Vector3 *)jarg2;
6601   if (!arg2) {
6602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6603     return 0;
6604   }
6605   {
6606     try {
6607       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6608     } catch (std::out_of_range& e) {
6609       {
6610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6611       };
6612     } catch (std::exception& e) {
6613       {
6614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6615       };
6616     } catch (Dali::DaliException e) {
6617       {
6618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6619       };
6620     } catch (...) {
6621       {
6622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6623       };
6624     }
6625   }
6626
6627   jresult = result;
6628   return jresult;
6629 }
6630
6631
6632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6633   void * jresult ;
6634   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6635   Dali::Vector3 *arg2 = 0 ;
6636   Dali::Vector3 result;
6637
6638   arg1 = (Dali::Vector3 *)jarg1;
6639   arg2 = (Dali::Vector3 *)jarg2;
6640   if (!arg2) {
6641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6642     return 0;
6643   }
6644   {
6645     try {
6646       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6647     } catch (std::out_of_range& e) {
6648       {
6649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6650       };
6651     } catch (std::exception& e) {
6652       {
6653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6654       };
6655     } catch (Dali::DaliException e) {
6656       {
6657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6658       };
6659     } catch (...) {
6660       {
6661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6662       };
6663     }
6664   }
6665
6666   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6667   return jresult;
6668 }
6669
6670
6671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6672   float jresult ;
6673   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6674   float result;
6675
6676   arg1 = (Dali::Vector3 *)jarg1;
6677   {
6678     try {
6679       result = (float)((Dali::Vector3 const *)arg1)->Length();
6680     } catch (std::out_of_range& e) {
6681       {
6682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6683       };
6684     } catch (std::exception& e) {
6685       {
6686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6687       };
6688     } catch (Dali::DaliException e) {
6689       {
6690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6691       };
6692     } catch (...) {
6693       {
6694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6695       };
6696     }
6697   }
6698
6699   jresult = result;
6700   return jresult;
6701 }
6702
6703
6704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6705   float jresult ;
6706   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6707   float result;
6708
6709   arg1 = (Dali::Vector3 *)jarg1;
6710   {
6711     try {
6712       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6713     } catch (std::out_of_range& e) {
6714       {
6715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6716       };
6717     } catch (std::exception& e) {
6718       {
6719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6720       };
6721     } catch (Dali::DaliException e) {
6722       {
6723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6724       };
6725     } catch (...) {
6726       {
6727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6728       };
6729     }
6730   }
6731
6732   jresult = result;
6733   return jresult;
6734 }
6735
6736
6737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6738   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6739
6740   arg1 = (Dali::Vector3 *)jarg1;
6741   {
6742     try {
6743       (arg1)->Normalize();
6744     } catch (std::out_of_range& e) {
6745       {
6746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6747       };
6748     } catch (std::exception& e) {
6749       {
6750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6751       };
6752     } catch (Dali::DaliException e) {
6753       {
6754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6755       };
6756     } catch (...) {
6757       {
6758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6759       };
6760     }
6761   }
6762
6763 }
6764
6765
6766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6767   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6768   Dali::Vector3 *arg2 = 0 ;
6769   Dali::Vector3 *arg3 = 0 ;
6770
6771   arg1 = (Dali::Vector3 *)jarg1;
6772   arg2 = (Dali::Vector3 *)jarg2;
6773   if (!arg2) {
6774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6775     return ;
6776   }
6777   arg3 = (Dali::Vector3 *)jarg3;
6778   if (!arg3) {
6779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6780     return ;
6781   }
6782   {
6783     try {
6784       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6785     } catch (std::out_of_range& e) {
6786       {
6787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6788       };
6789     } catch (std::exception& e) {
6790       {
6791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6792       };
6793     } catch (Dali::DaliException e) {
6794       {
6795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6796       };
6797     } catch (...) {
6798       {
6799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6800       };
6801     }
6802   }
6803
6804 }
6805
6806
6807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6808   void * jresult ;
6809   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6810   float *result = 0 ;
6811
6812   arg1 = (Dali::Vector3 *)jarg1;
6813   {
6814     try {
6815       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6816     } catch (std::out_of_range& e) {
6817       {
6818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6819       };
6820     } catch (std::exception& e) {
6821       {
6822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6823       };
6824     } catch (Dali::DaliException e) {
6825       {
6826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6827       };
6828     } catch (...) {
6829       {
6830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6831       };
6832     }
6833   }
6834
6835   jresult = (void *)result;
6836   return jresult;
6837 }
6838
6839
6840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6841   void * jresult ;
6842   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6843   Dali::Vector2 *result = 0 ;
6844
6845   arg1 = (Dali::Vector3 *)jarg1;
6846   {
6847     try {
6848       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6849     } catch (std::out_of_range& e) {
6850       {
6851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6852       };
6853     } catch (std::exception& e) {
6854       {
6855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6856       };
6857     } catch (Dali::DaliException e) {
6858       {
6859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6860       };
6861     } catch (...) {
6862       {
6863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6864       };
6865     }
6866   }
6867
6868   jresult = (void *)result;
6869   return jresult;
6870 }
6871
6872
6873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6874   void * jresult ;
6875   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6876   Dali::Vector2 *result = 0 ;
6877
6878   arg1 = (Dali::Vector3 *)jarg1;
6879   {
6880     try {
6881       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6882     } catch (std::out_of_range& e) {
6883       {
6884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6885       };
6886     } catch (std::exception& e) {
6887       {
6888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6889       };
6890     } catch (Dali::DaliException e) {
6891       {
6892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6893       };
6894     } catch (...) {
6895       {
6896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6897       };
6898     }
6899   }
6900
6901   jresult = (void *)result;
6902   return jresult;
6903 }
6904
6905
6906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6907   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6908   float arg2 ;
6909
6910   arg1 = (Dali::Vector3 *)jarg1;
6911   arg2 = (float)jarg2;
6912   if (arg1) (arg1)->x = arg2;
6913 }
6914
6915
6916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6917   float jresult ;
6918   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6919   float result;
6920
6921   arg1 = (Dali::Vector3 *)jarg1;
6922   result = (float) ((arg1)->x);
6923   jresult = result;
6924   return jresult;
6925 }
6926
6927
6928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6929   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6930   float arg2 ;
6931
6932   arg1 = (Dali::Vector3 *)jarg1;
6933   arg2 = (float)jarg2;
6934   if (arg1) (arg1)->width = arg2;
6935 }
6936
6937
6938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6939   float jresult ;
6940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6941   float result;
6942
6943   arg1 = (Dali::Vector3 *)jarg1;
6944   result = (float) ((arg1)->width);
6945   jresult = result;
6946   return jresult;
6947 }
6948
6949
6950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6951   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6952   float arg2 ;
6953
6954   arg1 = (Dali::Vector3 *)jarg1;
6955   arg2 = (float)jarg2;
6956   if (arg1) (arg1)->r = arg2;
6957 }
6958
6959
6960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6961   float jresult ;
6962   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6963   float result;
6964
6965   arg1 = (Dali::Vector3 *)jarg1;
6966   result = (float) ((arg1)->r);
6967   jresult = result;
6968   return jresult;
6969 }
6970
6971
6972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6973   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6974   float arg2 ;
6975
6976   arg1 = (Dali::Vector3 *)jarg1;
6977   arg2 = (float)jarg2;
6978   if (arg1) (arg1)->y = arg2;
6979 }
6980
6981
6982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6983   float jresult ;
6984   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6985   float result;
6986
6987   arg1 = (Dali::Vector3 *)jarg1;
6988   result = (float) ((arg1)->y);
6989   jresult = result;
6990   return jresult;
6991 }
6992
6993
6994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6995   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6996   float arg2 ;
6997
6998   arg1 = (Dali::Vector3 *)jarg1;
6999   arg2 = (float)jarg2;
7000   if (arg1) (arg1)->height = arg2;
7001 }
7002
7003
7004 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7005   float jresult ;
7006   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7007   float result;
7008
7009   arg1 = (Dali::Vector3 *)jarg1;
7010   result = (float) ((arg1)->height);
7011   jresult = result;
7012   return jresult;
7013 }
7014
7015
7016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7017   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7018   float arg2 ;
7019
7020   arg1 = (Dali::Vector3 *)jarg1;
7021   arg2 = (float)jarg2;
7022   if (arg1) (arg1)->g = arg2;
7023 }
7024
7025
7026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7027   float jresult ;
7028   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7029   float result;
7030
7031   arg1 = (Dali::Vector3 *)jarg1;
7032   result = (float) ((arg1)->g);
7033   jresult = result;
7034   return jresult;
7035 }
7036
7037
7038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7040   float arg2 ;
7041
7042   arg1 = (Dali::Vector3 *)jarg1;
7043   arg2 = (float)jarg2;
7044   if (arg1) (arg1)->z = arg2;
7045 }
7046
7047
7048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7049   float jresult ;
7050   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7051   float result;
7052
7053   arg1 = (Dali::Vector3 *)jarg1;
7054   result = (float) ((arg1)->z);
7055   jresult = result;
7056   return jresult;
7057 }
7058
7059
7060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7061   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7062   float arg2 ;
7063
7064   arg1 = (Dali::Vector3 *)jarg1;
7065   arg2 = (float)jarg2;
7066   if (arg1) (arg1)->depth = arg2;
7067 }
7068
7069
7070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7071   float jresult ;
7072   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7073   float result;
7074
7075   arg1 = (Dali::Vector3 *)jarg1;
7076   result = (float) ((arg1)->depth);
7077   jresult = result;
7078   return jresult;
7079 }
7080
7081
7082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7083   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7084   float arg2 ;
7085
7086   arg1 = (Dali::Vector3 *)jarg1;
7087   arg2 = (float)jarg2;
7088   if (arg1) (arg1)->b = arg2;
7089 }
7090
7091
7092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7093   float jresult ;
7094   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7095   float result;
7096
7097   arg1 = (Dali::Vector3 *)jarg1;
7098   result = (float) ((arg1)->b);
7099   jresult = result;
7100   return jresult;
7101 }
7102
7103
7104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7105   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7106
7107   arg1 = (Dali::Vector3 *)jarg1;
7108   {
7109     try {
7110       delete arg1;
7111     } catch (std::out_of_range& e) {
7112       {
7113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7114       };
7115     } catch (std::exception& e) {
7116       {
7117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7118       };
7119     } catch (Dali::DaliException e) {
7120       {
7121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7122       };
7123     } catch (...) {
7124       {
7125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7126       };
7127     }
7128   }
7129
7130 }
7131
7132
7133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7134   void * jresult ;
7135   Dali::Vector3 *arg1 = 0 ;
7136   Dali::Vector3 *arg2 = 0 ;
7137   Dali::Vector3 result;
7138
7139   arg1 = (Dali::Vector3 *)jarg1;
7140   if (!arg1) {
7141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7142     return 0;
7143   }
7144   arg2 = (Dali::Vector3 *)jarg2;
7145   if (!arg2) {
7146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7147     return 0;
7148   }
7149   {
7150     try {
7151       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7152     } catch (std::out_of_range& e) {
7153       {
7154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7155       };
7156     } catch (std::exception& e) {
7157       {
7158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7159       };
7160     } catch (Dali::DaliException e) {
7161       {
7162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7163       };
7164     } catch (...) {
7165       {
7166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7167       };
7168     }
7169   }
7170
7171   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7172   return jresult;
7173 }
7174
7175
7176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7177   void * jresult ;
7178   Dali::Vector3 *arg1 = 0 ;
7179   Dali::Vector3 *arg2 = 0 ;
7180   Dali::Vector3 result;
7181
7182   arg1 = (Dali::Vector3 *)jarg1;
7183   if (!arg1) {
7184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7185     return 0;
7186   }
7187   arg2 = (Dali::Vector3 *)jarg2;
7188   if (!arg2) {
7189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7190     return 0;
7191   }
7192   {
7193     try {
7194       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7195     } catch (std::out_of_range& e) {
7196       {
7197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7198       };
7199     } catch (std::exception& e) {
7200       {
7201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7202       };
7203     } catch (Dali::DaliException e) {
7204       {
7205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7206       };
7207     } catch (...) {
7208       {
7209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7210       };
7211     }
7212   }
7213
7214   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7215   return jresult;
7216 }
7217
7218
7219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7220   void * jresult ;
7221   Dali::Vector3 *arg1 = 0 ;
7222   float *arg2 = 0 ;
7223   float *arg3 = 0 ;
7224   float temp2 ;
7225   float temp3 ;
7226   Dali::Vector3 result;
7227
7228   arg1 = (Dali::Vector3 *)jarg1;
7229   if (!arg1) {
7230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7231     return 0;
7232   }
7233   temp2 = (float)jarg2;
7234   arg2 = &temp2;
7235   temp3 = (float)jarg3;
7236   arg3 = &temp3;
7237   {
7238     try {
7239       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7240     } catch (std::out_of_range& e) {
7241       {
7242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7243       };
7244     } catch (std::exception& e) {
7245       {
7246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7247       };
7248     } catch (Dali::DaliException e) {
7249       {
7250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7251       };
7252     } catch (...) {
7253       {
7254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7255       };
7256     }
7257   }
7258
7259   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7260   return jresult;
7261 }
7262
7263
7264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7265   void * jresult ;
7266   Dali::Vector4 *result = 0 ;
7267
7268   {
7269     try {
7270       result = (Dali::Vector4 *)new Dali::Vector4();
7271     } catch (std::out_of_range& e) {
7272       {
7273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7274       };
7275     } catch (std::exception& e) {
7276       {
7277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7278       };
7279     } catch (Dali::DaliException e) {
7280       {
7281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7282       };
7283     } catch (...) {
7284       {
7285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7286       };
7287     }
7288   }
7289
7290   jresult = (void *)result;
7291   return jresult;
7292 }
7293
7294
7295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7296   void * jresult ;
7297   float arg1 ;
7298   float arg2 ;
7299   float arg3 ;
7300   float arg4 ;
7301   Dali::Vector4 *result = 0 ;
7302
7303   arg1 = (float)jarg1;
7304   arg2 = (float)jarg2;
7305   arg3 = (float)jarg3;
7306   arg4 = (float)jarg4;
7307   {
7308     try {
7309       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7310     } catch (std::out_of_range& e) {
7311       {
7312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7313       };
7314     } catch (std::exception& e) {
7315       {
7316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7317       };
7318     } catch (Dali::DaliException e) {
7319       {
7320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7321       };
7322     } catch (...) {
7323       {
7324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7325       };
7326     }
7327   }
7328
7329   jresult = (void *)result;
7330   return jresult;
7331 }
7332
7333
7334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7335   void * jresult ;
7336   float *arg1 = (float *) 0 ;
7337   Dali::Vector4 *result = 0 ;
7338
7339   arg1 = jarg1;
7340   {
7341     try {
7342       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7343     } catch (std::out_of_range& e) {
7344       {
7345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7346       };
7347     } catch (std::exception& e) {
7348       {
7349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7350       };
7351     } catch (Dali::DaliException e) {
7352       {
7353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7354       };
7355     } catch (...) {
7356       {
7357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7358       };
7359     }
7360   }
7361
7362   jresult = (void *)result;
7363
7364
7365   return jresult;
7366 }
7367
7368
7369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7370   void * jresult ;
7371   Dali::Vector2 *arg1 = 0 ;
7372   Dali::Vector4 *result = 0 ;
7373
7374   arg1 = (Dali::Vector2 *)jarg1;
7375   if (!arg1) {
7376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7377     return 0;
7378   }
7379   {
7380     try {
7381       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7382     } catch (std::out_of_range& e) {
7383       {
7384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7385       };
7386     } catch (std::exception& e) {
7387       {
7388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7389       };
7390     } catch (Dali::DaliException e) {
7391       {
7392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7393       };
7394     } catch (...) {
7395       {
7396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7397       };
7398     }
7399   }
7400
7401   jresult = (void *)result;
7402   return jresult;
7403 }
7404
7405
7406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7407   void * jresult ;
7408   Dali::Vector3 *arg1 = 0 ;
7409   Dali::Vector4 *result = 0 ;
7410
7411   arg1 = (Dali::Vector3 *)jarg1;
7412   if (!arg1) {
7413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7414     return 0;
7415   }
7416   {
7417     try {
7418       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7419     } catch (std::out_of_range& e) {
7420       {
7421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7422       };
7423     } catch (std::exception& e) {
7424       {
7425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7426       };
7427     } catch (Dali::DaliException e) {
7428       {
7429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7430       };
7431     } catch (...) {
7432       {
7433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7434       };
7435     }
7436   }
7437
7438   jresult = (void *)result;
7439   return jresult;
7440 }
7441
7442
7443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7444   void * jresult ;
7445   Dali::Vector4 *result = 0 ;
7446
7447   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7448   jresult = (void *)result;
7449   return jresult;
7450 }
7451
7452
7453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7454   void * jresult ;
7455   Dali::Vector4 *result = 0 ;
7456
7457   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7458   jresult = (void *)result;
7459   return jresult;
7460 }
7461
7462
7463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7464   void * jresult ;
7465   Dali::Vector4 *result = 0 ;
7466
7467   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7468   jresult = (void *)result;
7469   return jresult;
7470 }
7471
7472
7473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7474   void * jresult ;
7475   Dali::Vector4 *result = 0 ;
7476
7477   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7478   jresult = (void *)result;
7479   return jresult;
7480 }
7481
7482
7483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7484   void * jresult ;
7485   Dali::Vector4 *result = 0 ;
7486
7487   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7488   jresult = (void *)result;
7489   return jresult;
7490 }
7491
7492
7493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7494   void * jresult ;
7495   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7496   float *arg2 = (float *) 0 ;
7497   Dali::Vector4 *result = 0 ;
7498
7499   arg1 = (Dali::Vector4 *)jarg1;
7500   arg2 = jarg2;
7501   {
7502     try {
7503       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7504     } catch (std::out_of_range& e) {
7505       {
7506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7507       };
7508     } catch (std::exception& e) {
7509       {
7510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7511       };
7512     } catch (Dali::DaliException e) {
7513       {
7514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7515       };
7516     } catch (...) {
7517       {
7518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7519       };
7520     }
7521   }
7522
7523   jresult = (void *)result;
7524
7525
7526   return jresult;
7527 }
7528
7529
7530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7531   void * jresult ;
7532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7533   Dali::Vector2 *arg2 = 0 ;
7534   Dali::Vector4 *result = 0 ;
7535
7536   arg1 = (Dali::Vector4 *)jarg1;
7537   arg2 = (Dali::Vector2 *)jarg2;
7538   if (!arg2) {
7539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7540     return 0;
7541   }
7542   {
7543     try {
7544       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7545     } catch (std::out_of_range& e) {
7546       {
7547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7548       };
7549     } catch (std::exception& e) {
7550       {
7551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7552       };
7553     } catch (Dali::DaliException e) {
7554       {
7555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7556       };
7557     } catch (...) {
7558       {
7559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7560       };
7561     }
7562   }
7563
7564   jresult = (void *)result;
7565   return jresult;
7566 }
7567
7568
7569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7570   void * jresult ;
7571   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7572   Dali::Vector3 *arg2 = 0 ;
7573   Dali::Vector4 *result = 0 ;
7574
7575   arg1 = (Dali::Vector4 *)jarg1;
7576   arg2 = (Dali::Vector3 *)jarg2;
7577   if (!arg2) {
7578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7579     return 0;
7580   }
7581   {
7582     try {
7583       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7584     } catch (std::out_of_range& e) {
7585       {
7586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7587       };
7588     } catch (std::exception& e) {
7589       {
7590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7591       };
7592     } catch (Dali::DaliException e) {
7593       {
7594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7595       };
7596     } catch (...) {
7597       {
7598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7599       };
7600     }
7601   }
7602
7603   jresult = (void *)result;
7604   return jresult;
7605 }
7606
7607
7608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7609   void * jresult ;
7610   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7611   Dali::Vector4 *arg2 = 0 ;
7612   Dali::Vector4 result;
7613
7614   arg1 = (Dali::Vector4 *)jarg1;
7615   arg2 = (Dali::Vector4 *)jarg2;
7616   if (!arg2) {
7617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7618     return 0;
7619   }
7620   {
7621     try {
7622       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7623     } catch (std::out_of_range& e) {
7624       {
7625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7626       };
7627     } catch (std::exception& e) {
7628       {
7629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7630       };
7631     } catch (Dali::DaliException e) {
7632       {
7633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7634       };
7635     } catch (...) {
7636       {
7637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7638       };
7639     }
7640   }
7641
7642   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7643   return jresult;
7644 }
7645
7646
7647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7648   void * jresult ;
7649   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7650   Dali::Vector4 *arg2 = 0 ;
7651   Dali::Vector4 *result = 0 ;
7652
7653   arg1 = (Dali::Vector4 *)jarg1;
7654   arg2 = (Dali::Vector4 *)jarg2;
7655   if (!arg2) {
7656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7657     return 0;
7658   }
7659   {
7660     try {
7661       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7662     } catch (std::out_of_range& e) {
7663       {
7664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7665       };
7666     } catch (std::exception& e) {
7667       {
7668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7669       };
7670     } catch (Dali::DaliException e) {
7671       {
7672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7673       };
7674     } catch (...) {
7675       {
7676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7677       };
7678     }
7679   }
7680
7681   jresult = (void *)result;
7682   return jresult;
7683 }
7684
7685
7686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7687   void * jresult ;
7688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7689   Dali::Vector4 *arg2 = 0 ;
7690   Dali::Vector4 result;
7691
7692   arg1 = (Dali::Vector4 *)jarg1;
7693   arg2 = (Dali::Vector4 *)jarg2;
7694   if (!arg2) {
7695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7696     return 0;
7697   }
7698   {
7699     try {
7700       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7701     } catch (std::out_of_range& e) {
7702       {
7703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7704       };
7705     } catch (std::exception& e) {
7706       {
7707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7708       };
7709     } catch (Dali::DaliException e) {
7710       {
7711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7712       };
7713     } catch (...) {
7714       {
7715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7716       };
7717     }
7718   }
7719
7720   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7721   return jresult;
7722 }
7723
7724
7725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7726   void * jresult ;
7727   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7728   Dali::Vector4 *arg2 = 0 ;
7729   Dali::Vector4 *result = 0 ;
7730
7731   arg1 = (Dali::Vector4 *)jarg1;
7732   arg2 = (Dali::Vector4 *)jarg2;
7733   if (!arg2) {
7734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7735     return 0;
7736   }
7737   {
7738     try {
7739       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7740     } catch (std::out_of_range& e) {
7741       {
7742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7743       };
7744     } catch (std::exception& e) {
7745       {
7746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7747       };
7748     } catch (Dali::DaliException e) {
7749       {
7750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7751       };
7752     } catch (...) {
7753       {
7754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7755       };
7756     }
7757   }
7758
7759   jresult = (void *)result;
7760   return jresult;
7761 }
7762
7763
7764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7765   void * jresult ;
7766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7767   Dali::Vector4 *arg2 = 0 ;
7768   Dali::Vector4 result;
7769
7770   arg1 = (Dali::Vector4 *)jarg1;
7771   arg2 = (Dali::Vector4 *)jarg2;
7772   if (!arg2) {
7773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7774     return 0;
7775   }
7776   {
7777     try {
7778       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7779     } catch (std::out_of_range& e) {
7780       {
7781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7782       };
7783     } catch (std::exception& e) {
7784       {
7785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7786       };
7787     } catch (Dali::DaliException e) {
7788       {
7789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7790       };
7791     } catch (...) {
7792       {
7793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7794       };
7795     }
7796   }
7797
7798   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7799   return jresult;
7800 }
7801
7802
7803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7804   void * jresult ;
7805   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7806   float arg2 ;
7807   Dali::Vector4 result;
7808
7809   arg1 = (Dali::Vector4 *)jarg1;
7810   arg2 = (float)jarg2;
7811   {
7812     try {
7813       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7814     } catch (std::out_of_range& e) {
7815       {
7816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7817       };
7818     } catch (std::exception& e) {
7819       {
7820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7821       };
7822     } catch (Dali::DaliException e) {
7823       {
7824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7825       };
7826     } catch (...) {
7827       {
7828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7829       };
7830     }
7831   }
7832
7833   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7834   return jresult;
7835 }
7836
7837
7838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7839   void * jresult ;
7840   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7841   Dali::Vector4 *arg2 = 0 ;
7842   Dali::Vector4 *result = 0 ;
7843
7844   arg1 = (Dali::Vector4 *)jarg1;
7845   arg2 = (Dali::Vector4 *)jarg2;
7846   if (!arg2) {
7847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7848     return 0;
7849   }
7850   {
7851     try {
7852       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7853     } catch (std::out_of_range& e) {
7854       {
7855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7856       };
7857     } catch (std::exception& e) {
7858       {
7859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7860       };
7861     } catch (Dali::DaliException e) {
7862       {
7863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7864       };
7865     } catch (...) {
7866       {
7867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7868       };
7869     }
7870   }
7871
7872   jresult = (void *)result;
7873   return jresult;
7874 }
7875
7876
7877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7878   void * jresult ;
7879   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7880   float arg2 ;
7881   Dali::Vector4 *result = 0 ;
7882
7883   arg1 = (Dali::Vector4 *)jarg1;
7884   arg2 = (float)jarg2;
7885   {
7886     try {
7887       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7888     } catch (std::out_of_range& e) {
7889       {
7890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7891       };
7892     } catch (std::exception& e) {
7893       {
7894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7895       };
7896     } catch (Dali::DaliException e) {
7897       {
7898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7899       };
7900     } catch (...) {
7901       {
7902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7903       };
7904     }
7905   }
7906
7907   jresult = (void *)result;
7908   return jresult;
7909 }
7910
7911
7912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7913   void * jresult ;
7914   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7915   Dali::Vector4 *arg2 = 0 ;
7916   Dali::Vector4 result;
7917
7918   arg1 = (Dali::Vector4 *)jarg1;
7919   arg2 = (Dali::Vector4 *)jarg2;
7920   if (!arg2) {
7921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7922     return 0;
7923   }
7924   {
7925     try {
7926       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7927     } catch (std::out_of_range& e) {
7928       {
7929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7930       };
7931     } catch (std::exception& e) {
7932       {
7933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7934       };
7935     } catch (Dali::DaliException e) {
7936       {
7937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7938       };
7939     } catch (...) {
7940       {
7941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7942       };
7943     }
7944   }
7945
7946   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7947   return jresult;
7948 }
7949
7950
7951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7952   void * jresult ;
7953   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7954   float arg2 ;
7955   Dali::Vector4 result;
7956
7957   arg1 = (Dali::Vector4 *)jarg1;
7958   arg2 = (float)jarg2;
7959   {
7960     try {
7961       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7962     } catch (std::out_of_range& e) {
7963       {
7964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7965       };
7966     } catch (std::exception& e) {
7967       {
7968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7969       };
7970     } catch (Dali::DaliException e) {
7971       {
7972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7973       };
7974     } catch (...) {
7975       {
7976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7977       };
7978     }
7979   }
7980
7981   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7982   return jresult;
7983 }
7984
7985
7986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7987   void * jresult ;
7988   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7989   Dali::Vector4 *arg2 = 0 ;
7990   Dali::Vector4 *result = 0 ;
7991
7992   arg1 = (Dali::Vector4 *)jarg1;
7993   arg2 = (Dali::Vector4 *)jarg2;
7994   if (!arg2) {
7995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7996     return 0;
7997   }
7998   {
7999     try {
8000       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8001     } catch (std::out_of_range& e) {
8002       {
8003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8004       };
8005     } catch (std::exception& e) {
8006       {
8007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8008       };
8009     } catch (Dali::DaliException e) {
8010       {
8011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8012       };
8013     } catch (...) {
8014       {
8015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8016       };
8017     }
8018   }
8019
8020   jresult = (void *)result;
8021   return jresult;
8022 }
8023
8024
8025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8026   void * jresult ;
8027   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8028   float arg2 ;
8029   Dali::Vector4 *result = 0 ;
8030
8031   arg1 = (Dali::Vector4 *)jarg1;
8032   arg2 = (float)jarg2;
8033   {
8034     try {
8035       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8036     } catch (std::out_of_range& e) {
8037       {
8038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8039       };
8040     } catch (std::exception& e) {
8041       {
8042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8043       };
8044     } catch (Dali::DaliException e) {
8045       {
8046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8047       };
8048     } catch (...) {
8049       {
8050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8051       };
8052     }
8053   }
8054
8055   jresult = (void *)result;
8056   return jresult;
8057 }
8058
8059
8060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8061   void * jresult ;
8062   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8063   Dali::Vector4 result;
8064
8065   arg1 = (Dali::Vector4 *)jarg1;
8066   {
8067     try {
8068       result = ((Dali::Vector4 const *)arg1)->operator -();
8069     } catch (std::out_of_range& e) {
8070       {
8071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8072       };
8073     } catch (std::exception& e) {
8074       {
8075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8076       };
8077     } catch (Dali::DaliException e) {
8078       {
8079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8080       };
8081     } catch (...) {
8082       {
8083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8084       };
8085     }
8086   }
8087
8088   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8089   return jresult;
8090 }
8091
8092
8093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8094   unsigned int jresult ;
8095   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8096   Dali::Vector4 *arg2 = 0 ;
8097   bool result;
8098
8099   arg1 = (Dali::Vector4 *)jarg1;
8100   arg2 = (Dali::Vector4 *)jarg2;
8101   if (!arg2) {
8102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8103     return 0;
8104   }
8105   {
8106     try {
8107       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8108     } catch (std::out_of_range& e) {
8109       {
8110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8111       };
8112     } catch (std::exception& e) {
8113       {
8114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8115       };
8116     } catch (Dali::DaliException e) {
8117       {
8118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8119       };
8120     } catch (...) {
8121       {
8122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8123       };
8124     }
8125   }
8126
8127   jresult = result;
8128   return jresult;
8129 }
8130
8131
8132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8133   unsigned int jresult ;
8134   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8135   Dali::Vector4 *arg2 = 0 ;
8136   bool result;
8137
8138   arg1 = (Dali::Vector4 *)jarg1;
8139   arg2 = (Dali::Vector4 *)jarg2;
8140   if (!arg2) {
8141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8142     return 0;
8143   }
8144   {
8145     try {
8146       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8147     } catch (std::out_of_range& e) {
8148       {
8149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8150       };
8151     } catch (std::exception& e) {
8152       {
8153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8154       };
8155     } catch (Dali::DaliException e) {
8156       {
8157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8158       };
8159     } catch (...) {
8160       {
8161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8162       };
8163     }
8164   }
8165
8166   jresult = result;
8167   return jresult;
8168 }
8169
8170
8171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8172   float jresult ;
8173   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8174   unsigned int arg2 ;
8175   float *result = 0 ;
8176
8177   arg1 = (Dali::Vector4 *)jarg1;
8178   arg2 = (unsigned int)jarg2;
8179   {
8180     try {
8181       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8182     } catch (std::out_of_range& e) {
8183       {
8184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8185       };
8186     } catch (std::exception& e) {
8187       {
8188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8189       };
8190     } catch (Dali::DaliException e) {
8191       {
8192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8193       };
8194     } catch (...) {
8195       {
8196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8197       };
8198     }
8199   }
8200
8201   jresult = *result;
8202   return jresult;
8203 }
8204
8205
8206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8207   float jresult ;
8208   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8209   Dali::Vector3 *arg2 = 0 ;
8210   float result;
8211
8212   arg1 = (Dali::Vector4 *)jarg1;
8213   arg2 = (Dali::Vector3 *)jarg2;
8214   if (!arg2) {
8215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8216     return 0;
8217   }
8218   {
8219     try {
8220       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8221     } catch (std::out_of_range& e) {
8222       {
8223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8224       };
8225     } catch (std::exception& e) {
8226       {
8227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8228       };
8229     } catch (Dali::DaliException e) {
8230       {
8231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8232       };
8233     } catch (...) {
8234       {
8235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8236       };
8237     }
8238   }
8239
8240   jresult = result;
8241   return jresult;
8242 }
8243
8244
8245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8246   float jresult ;
8247   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8248   Dali::Vector4 *arg2 = 0 ;
8249   float result;
8250
8251   arg1 = (Dali::Vector4 *)jarg1;
8252   arg2 = (Dali::Vector4 *)jarg2;
8253   if (!arg2) {
8254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8255     return 0;
8256   }
8257   {
8258     try {
8259       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8260     } catch (std::out_of_range& e) {
8261       {
8262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8263       };
8264     } catch (std::exception& e) {
8265       {
8266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8267       };
8268     } catch (Dali::DaliException e) {
8269       {
8270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8271       };
8272     } catch (...) {
8273       {
8274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8275       };
8276     }
8277   }
8278
8279   jresult = result;
8280   return jresult;
8281 }
8282
8283
8284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8285   float jresult ;
8286   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8287   Dali::Vector4 *arg2 = 0 ;
8288   float result;
8289
8290   arg1 = (Dali::Vector4 *)jarg1;
8291   arg2 = (Dali::Vector4 *)jarg2;
8292   if (!arg2) {
8293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8294     return 0;
8295   }
8296   {
8297     try {
8298       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8299     } catch (std::out_of_range& e) {
8300       {
8301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8302       };
8303     } catch (std::exception& e) {
8304       {
8305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8306       };
8307     } catch (Dali::DaliException e) {
8308       {
8309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8310       };
8311     } catch (...) {
8312       {
8313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8314       };
8315     }
8316   }
8317
8318   jresult = result;
8319   return jresult;
8320 }
8321
8322
8323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8324   void * jresult ;
8325   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8326   Dali::Vector4 *arg2 = 0 ;
8327   Dali::Vector4 result;
8328
8329   arg1 = (Dali::Vector4 *)jarg1;
8330   arg2 = (Dali::Vector4 *)jarg2;
8331   if (!arg2) {
8332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8333     return 0;
8334   }
8335   {
8336     try {
8337       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8338     } catch (std::out_of_range& e) {
8339       {
8340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8341       };
8342     } catch (std::exception& e) {
8343       {
8344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8345       };
8346     } catch (Dali::DaliException e) {
8347       {
8348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8349       };
8350     } catch (...) {
8351       {
8352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8353       };
8354     }
8355   }
8356
8357   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8358   return jresult;
8359 }
8360
8361
8362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8363   float jresult ;
8364   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8365   float result;
8366
8367   arg1 = (Dali::Vector4 *)jarg1;
8368   {
8369     try {
8370       result = (float)((Dali::Vector4 const *)arg1)->Length();
8371     } catch (std::out_of_range& e) {
8372       {
8373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8374       };
8375     } catch (std::exception& e) {
8376       {
8377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8378       };
8379     } catch (Dali::DaliException e) {
8380       {
8381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8382       };
8383     } catch (...) {
8384       {
8385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8386       };
8387     }
8388   }
8389
8390   jresult = result;
8391   return jresult;
8392 }
8393
8394
8395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8396   float jresult ;
8397   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8398   float result;
8399
8400   arg1 = (Dali::Vector4 *)jarg1;
8401   {
8402     try {
8403       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8404     } catch (std::out_of_range& e) {
8405       {
8406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8407       };
8408     } catch (std::exception& e) {
8409       {
8410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8411       };
8412     } catch (Dali::DaliException e) {
8413       {
8414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8415       };
8416     } catch (...) {
8417       {
8418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8419       };
8420     }
8421   }
8422
8423   jresult = result;
8424   return jresult;
8425 }
8426
8427
8428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8429   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8430
8431   arg1 = (Dali::Vector4 *)jarg1;
8432   {
8433     try {
8434       (arg1)->Normalize();
8435     } catch (std::out_of_range& e) {
8436       {
8437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8438       };
8439     } catch (std::exception& e) {
8440       {
8441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8442       };
8443     } catch (Dali::DaliException e) {
8444       {
8445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8446       };
8447     } catch (...) {
8448       {
8449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8450       };
8451     }
8452   }
8453
8454 }
8455
8456
8457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8458   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8459   Dali::Vector4 *arg2 = 0 ;
8460   Dali::Vector4 *arg3 = 0 ;
8461
8462   arg1 = (Dali::Vector4 *)jarg1;
8463   arg2 = (Dali::Vector4 *)jarg2;
8464   if (!arg2) {
8465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8466     return ;
8467   }
8468   arg3 = (Dali::Vector4 *)jarg3;
8469   if (!arg3) {
8470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8471     return ;
8472   }
8473   {
8474     try {
8475       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8476     } catch (std::out_of_range& e) {
8477       {
8478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8479       };
8480     } catch (std::exception& e) {
8481       {
8482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8483       };
8484     } catch (Dali::DaliException e) {
8485       {
8486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8487       };
8488     } catch (...) {
8489       {
8490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8491       };
8492     }
8493   }
8494
8495 }
8496
8497
8498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8499   void * jresult ;
8500   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8501   float *result = 0 ;
8502
8503   arg1 = (Dali::Vector4 *)jarg1;
8504   {
8505     try {
8506       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8507     } catch (std::out_of_range& e) {
8508       {
8509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8510       };
8511     } catch (std::exception& e) {
8512       {
8513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8514       };
8515     } catch (Dali::DaliException e) {
8516       {
8517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8518       };
8519     } catch (...) {
8520       {
8521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8522       };
8523     }
8524   }
8525
8526   jresult = (void *)result;
8527   return jresult;
8528 }
8529
8530
8531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8533   float arg2 ;
8534
8535   arg1 = (Dali::Vector4 *)jarg1;
8536   arg2 = (float)jarg2;
8537   if (arg1) (arg1)->x = arg2;
8538 }
8539
8540
8541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8542   float jresult ;
8543   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8544   float result;
8545
8546   arg1 = (Dali::Vector4 *)jarg1;
8547   result = (float) ((arg1)->x);
8548   jresult = result;
8549   return jresult;
8550 }
8551
8552
8553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8554   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8555   float arg2 ;
8556
8557   arg1 = (Dali::Vector4 *)jarg1;
8558   arg2 = (float)jarg2;
8559   if (arg1) (arg1)->r = arg2;
8560 }
8561
8562
8563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8564   float jresult ;
8565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8566   float result;
8567
8568   arg1 = (Dali::Vector4 *)jarg1;
8569   result = (float) ((arg1)->r);
8570   jresult = result;
8571   return jresult;
8572 }
8573
8574
8575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8577   float arg2 ;
8578
8579   arg1 = (Dali::Vector4 *)jarg1;
8580   arg2 = (float)jarg2;
8581   if (arg1) (arg1)->s = arg2;
8582 }
8583
8584
8585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8586   float jresult ;
8587   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8588   float result;
8589
8590   arg1 = (Dali::Vector4 *)jarg1;
8591   result = (float) ((arg1)->s);
8592   jresult = result;
8593   return jresult;
8594 }
8595
8596
8597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8599   float arg2 ;
8600
8601   arg1 = (Dali::Vector4 *)jarg1;
8602   arg2 = (float)jarg2;
8603   if (arg1) (arg1)->y = arg2;
8604 }
8605
8606
8607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8608   float jresult ;
8609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8610   float result;
8611
8612   arg1 = (Dali::Vector4 *)jarg1;
8613   result = (float) ((arg1)->y);
8614   jresult = result;
8615   return jresult;
8616 }
8617
8618
8619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8621   float arg2 ;
8622
8623   arg1 = (Dali::Vector4 *)jarg1;
8624   arg2 = (float)jarg2;
8625   if (arg1) (arg1)->g = arg2;
8626 }
8627
8628
8629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8630   float jresult ;
8631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8632   float result;
8633
8634   arg1 = (Dali::Vector4 *)jarg1;
8635   result = (float) ((arg1)->g);
8636   jresult = result;
8637   return jresult;
8638 }
8639
8640
8641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8643   float arg2 ;
8644
8645   arg1 = (Dali::Vector4 *)jarg1;
8646   arg2 = (float)jarg2;
8647   if (arg1) (arg1)->t = arg2;
8648 }
8649
8650
8651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8652   float jresult ;
8653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8654   float result;
8655
8656   arg1 = (Dali::Vector4 *)jarg1;
8657   result = (float) ((arg1)->t);
8658   jresult = result;
8659   return jresult;
8660 }
8661
8662
8663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8665   float arg2 ;
8666
8667   arg1 = (Dali::Vector4 *)jarg1;
8668   arg2 = (float)jarg2;
8669   if (arg1) (arg1)->z = arg2;
8670 }
8671
8672
8673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8674   float jresult ;
8675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8676   float result;
8677
8678   arg1 = (Dali::Vector4 *)jarg1;
8679   result = (float) ((arg1)->z);
8680   jresult = result;
8681   return jresult;
8682 }
8683
8684
8685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8687   float arg2 ;
8688
8689   arg1 = (Dali::Vector4 *)jarg1;
8690   arg2 = (float)jarg2;
8691   if (arg1) (arg1)->b = arg2;
8692 }
8693
8694
8695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8696   float jresult ;
8697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8698   float result;
8699
8700   arg1 = (Dali::Vector4 *)jarg1;
8701   result = (float) ((arg1)->b);
8702   jresult = result;
8703   return jresult;
8704 }
8705
8706
8707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8709   float arg2 ;
8710
8711   arg1 = (Dali::Vector4 *)jarg1;
8712   arg2 = (float)jarg2;
8713   if (arg1) (arg1)->p = arg2;
8714 }
8715
8716
8717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8718   float jresult ;
8719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8720   float result;
8721
8722   arg1 = (Dali::Vector4 *)jarg1;
8723   result = (float) ((arg1)->p);
8724   jresult = result;
8725   return jresult;
8726 }
8727
8728
8729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8731   float arg2 ;
8732
8733   arg1 = (Dali::Vector4 *)jarg1;
8734   arg2 = (float)jarg2;
8735   if (arg1) (arg1)->w = arg2;
8736 }
8737
8738
8739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8740   float jresult ;
8741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8742   float result;
8743
8744   arg1 = (Dali::Vector4 *)jarg1;
8745   result = (float) ((arg1)->w);
8746   jresult = result;
8747   return jresult;
8748 }
8749
8750
8751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8753   float arg2 ;
8754
8755   arg1 = (Dali::Vector4 *)jarg1;
8756   arg2 = (float)jarg2;
8757   if (arg1) (arg1)->a = arg2;
8758 }
8759
8760
8761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8762   float jresult ;
8763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8764   float result;
8765
8766   arg1 = (Dali::Vector4 *)jarg1;
8767   result = (float) ((arg1)->a);
8768   jresult = result;
8769   return jresult;
8770 }
8771
8772
8773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8774   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8775   float arg2 ;
8776
8777   arg1 = (Dali::Vector4 *)jarg1;
8778   arg2 = (float)jarg2;
8779   if (arg1) (arg1)->q = arg2;
8780 }
8781
8782
8783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8784   float jresult ;
8785   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8786   float result;
8787
8788   arg1 = (Dali::Vector4 *)jarg1;
8789   result = (float) ((arg1)->q);
8790   jresult = result;
8791   return jresult;
8792 }
8793
8794
8795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8796   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8797
8798   arg1 = (Dali::Vector4 *)jarg1;
8799   {
8800     try {
8801       delete arg1;
8802     } catch (std::out_of_range& e) {
8803       {
8804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8805       };
8806     } catch (std::exception& e) {
8807       {
8808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8809       };
8810     } catch (Dali::DaliException e) {
8811       {
8812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8813       };
8814     } catch (...) {
8815       {
8816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8817       };
8818     }
8819   }
8820
8821 }
8822
8823
8824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8825   void * jresult ;
8826   Dali::Vector4 *arg1 = 0 ;
8827   Dali::Vector4 *arg2 = 0 ;
8828   Dali::Vector4 result;
8829
8830   arg1 = (Dali::Vector4 *)jarg1;
8831   if (!arg1) {
8832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8833     return 0;
8834   }
8835   arg2 = (Dali::Vector4 *)jarg2;
8836   if (!arg2) {
8837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8838     return 0;
8839   }
8840   {
8841     try {
8842       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8843     } catch (std::out_of_range& e) {
8844       {
8845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8846       };
8847     } catch (std::exception& e) {
8848       {
8849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8850       };
8851     } catch (Dali::DaliException e) {
8852       {
8853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8854       };
8855     } catch (...) {
8856       {
8857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8858       };
8859     }
8860   }
8861
8862   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8863   return jresult;
8864 }
8865
8866
8867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8868   void * jresult ;
8869   Dali::Vector4 *arg1 = 0 ;
8870   Dali::Vector4 *arg2 = 0 ;
8871   Dali::Vector4 result;
8872
8873   arg1 = (Dali::Vector4 *)jarg1;
8874   if (!arg1) {
8875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8876     return 0;
8877   }
8878   arg2 = (Dali::Vector4 *)jarg2;
8879   if (!arg2) {
8880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8881     return 0;
8882   }
8883   {
8884     try {
8885       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8886     } catch (std::out_of_range& e) {
8887       {
8888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8889       };
8890     } catch (std::exception& e) {
8891       {
8892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8893       };
8894     } catch (Dali::DaliException e) {
8895       {
8896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8897       };
8898     } catch (...) {
8899       {
8900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8901       };
8902     }
8903   }
8904
8905   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8906   return jresult;
8907 }
8908
8909
8910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8911   void * jresult ;
8912   Dali::Vector4 *arg1 = 0 ;
8913   float *arg2 = 0 ;
8914   float *arg3 = 0 ;
8915   float temp2 ;
8916   float temp3 ;
8917   Dali::Vector4 result;
8918
8919   arg1 = (Dali::Vector4 *)jarg1;
8920   if (!arg1) {
8921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8922     return 0;
8923   }
8924   temp2 = (float)jarg2;
8925   arg2 = &temp2;
8926   temp3 = (float)jarg3;
8927   arg3 = &temp3;
8928   {
8929     try {
8930       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8931     } catch (std::out_of_range& e) {
8932       {
8933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8934       };
8935     } catch (std::exception& e) {
8936       {
8937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8938       };
8939     } catch (Dali::DaliException e) {
8940       {
8941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8942       };
8943     } catch (...) {
8944       {
8945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8946       };
8947     }
8948   }
8949
8950   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8951   return jresult;
8952 }
8953
8954
8955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8956   void * jresult ;
8957   Dali::Uint16Pair *result = 0 ;
8958
8959   {
8960     try {
8961       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8962     } catch (std::out_of_range& e) {
8963       {
8964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8965       };
8966     } catch (std::exception& e) {
8967       {
8968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8969       };
8970     } catch (Dali::DaliException e) {
8971       {
8972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8973       };
8974     } catch (...) {
8975       {
8976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8977       };
8978     }
8979   }
8980
8981   jresult = (void *)result;
8982   return jresult;
8983 }
8984
8985
8986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8987   void * jresult ;
8988   uint32_t arg1 ;
8989   uint32_t arg2 ;
8990   Dali::Uint16Pair *result = 0 ;
8991
8992   arg1 = (uint32_t)jarg1;
8993   arg2 = (uint32_t)jarg2;
8994   {
8995     try {
8996       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8997     } catch (std::out_of_range& e) {
8998       {
8999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9000       };
9001     } catch (std::exception& e) {
9002       {
9003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9004       };
9005     } catch (Dali::DaliException e) {
9006       {
9007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9008       };
9009     } catch (...) {
9010       {
9011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9012       };
9013     }
9014   }
9015
9016   jresult = (void *)result;
9017   return jresult;
9018 }
9019
9020
9021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9022   void * jresult ;
9023   Dali::Uint16Pair *arg1 = 0 ;
9024   Dali::Uint16Pair *result = 0 ;
9025
9026   arg1 = (Dali::Uint16Pair *)jarg1;
9027   if (!arg1) {
9028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9029     return 0;
9030   }
9031   {
9032     try {
9033       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9034     } catch (std::out_of_range& e) {
9035       {
9036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9037       };
9038     } catch (std::exception& e) {
9039       {
9040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9041       };
9042     } catch (Dali::DaliException e) {
9043       {
9044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9045       };
9046     } catch (...) {
9047       {
9048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9049       };
9050     }
9051   }
9052
9053   jresult = (void *)result;
9054   return jresult;
9055 }
9056
9057
9058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9059   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9060   uint16_t arg2 ;
9061
9062   arg1 = (Dali::Uint16Pair *)jarg1;
9063   arg2 = (uint16_t)jarg2;
9064   {
9065     try {
9066       (arg1)->SetWidth(arg2);
9067     } catch (std::out_of_range& e) {
9068       {
9069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9070       };
9071     } catch (std::exception& e) {
9072       {
9073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9074       };
9075     } catch (Dali::DaliException e) {
9076       {
9077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9078       };
9079     } catch (...) {
9080       {
9081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9082       };
9083     }
9084   }
9085
9086 }
9087
9088
9089 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9090   unsigned short jresult ;
9091   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9092   uint16_t result;
9093
9094   arg1 = (Dali::Uint16Pair *)jarg1;
9095   {
9096     try {
9097       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9098     } catch (std::out_of_range& e) {
9099       {
9100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9101       };
9102     } catch (std::exception& e) {
9103       {
9104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9105       };
9106     } catch (Dali::DaliException e) {
9107       {
9108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9109       };
9110     } catch (...) {
9111       {
9112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9113       };
9114     }
9115   }
9116
9117   jresult = result;
9118   return jresult;
9119 }
9120
9121
9122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9123   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9124   uint16_t arg2 ;
9125
9126   arg1 = (Dali::Uint16Pair *)jarg1;
9127   arg2 = (uint16_t)jarg2;
9128   {
9129     try {
9130       (arg1)->SetHeight(arg2);
9131     } catch (std::out_of_range& e) {
9132       {
9133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9134       };
9135     } catch (std::exception& e) {
9136       {
9137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9138       };
9139     } catch (Dali::DaliException e) {
9140       {
9141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9142       };
9143     } catch (...) {
9144       {
9145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9146       };
9147     }
9148   }
9149
9150 }
9151
9152
9153 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9154   unsigned short jresult ;
9155   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9156   uint16_t result;
9157
9158   arg1 = (Dali::Uint16Pair *)jarg1;
9159   {
9160     try {
9161       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9162     } catch (std::out_of_range& e) {
9163       {
9164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9165       };
9166     } catch (std::exception& e) {
9167       {
9168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9169       };
9170     } catch (Dali::DaliException e) {
9171       {
9172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9173       };
9174     } catch (...) {
9175       {
9176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9177       };
9178     }
9179   }
9180
9181   jresult = result;
9182   return jresult;
9183 }
9184
9185
9186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9187   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9188   uint16_t arg2 ;
9189
9190   arg1 = (Dali::Uint16Pair *)jarg1;
9191   arg2 = (uint16_t)jarg2;
9192   {
9193     try {
9194       (arg1)->SetX(arg2);
9195     } catch (std::out_of_range& e) {
9196       {
9197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9198       };
9199     } catch (std::exception& e) {
9200       {
9201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9202       };
9203     } catch (Dali::DaliException e) {
9204       {
9205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9206       };
9207     } catch (...) {
9208       {
9209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9210       };
9211     }
9212   }
9213
9214 }
9215
9216
9217 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9218   unsigned short jresult ;
9219   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9220   uint16_t result;
9221
9222   arg1 = (Dali::Uint16Pair *)jarg1;
9223   {
9224     try {
9225       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9226     } catch (std::out_of_range& e) {
9227       {
9228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9229       };
9230     } catch (std::exception& e) {
9231       {
9232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9233       };
9234     } catch (Dali::DaliException e) {
9235       {
9236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9237       };
9238     } catch (...) {
9239       {
9240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9241       };
9242     }
9243   }
9244
9245   jresult = result;
9246   return jresult;
9247 }
9248
9249
9250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9251   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9252   uint16_t arg2 ;
9253
9254   arg1 = (Dali::Uint16Pair *)jarg1;
9255   arg2 = (uint16_t)jarg2;
9256   {
9257     try {
9258       (arg1)->SetY(arg2);
9259     } catch (std::out_of_range& e) {
9260       {
9261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9262       };
9263     } catch (std::exception& e) {
9264       {
9265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9266       };
9267     } catch (Dali::DaliException e) {
9268       {
9269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9270       };
9271     } catch (...) {
9272       {
9273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9274       };
9275     }
9276   }
9277
9278 }
9279
9280
9281 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9282   unsigned short jresult ;
9283   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9284   uint16_t result;
9285
9286   arg1 = (Dali::Uint16Pair *)jarg1;
9287   {
9288     try {
9289       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9290     } catch (std::out_of_range& e) {
9291       {
9292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9293       };
9294     } catch (std::exception& e) {
9295       {
9296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9297       };
9298     } catch (Dali::DaliException e) {
9299       {
9300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9301       };
9302     } catch (...) {
9303       {
9304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9305       };
9306     }
9307   }
9308
9309   jresult = result;
9310   return jresult;
9311 }
9312
9313
9314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9315   void * jresult ;
9316   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9317   Dali::Uint16Pair *arg2 = 0 ;
9318   Dali::Uint16Pair *result = 0 ;
9319
9320   arg1 = (Dali::Uint16Pair *)jarg1;
9321   arg2 = (Dali::Uint16Pair *)jarg2;
9322   if (!arg2) {
9323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9324     return 0;
9325   }
9326   {
9327     try {
9328       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9329     } catch (std::out_of_range& e) {
9330       {
9331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9332       };
9333     } catch (std::exception& e) {
9334       {
9335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9336       };
9337     } catch (Dali::DaliException e) {
9338       {
9339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9340       };
9341     } catch (...) {
9342       {
9343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9344       };
9345     }
9346   }
9347
9348   jresult = (void *)result;
9349   return jresult;
9350 }
9351
9352
9353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9354   unsigned int jresult ;
9355   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9356   Dali::Uint16Pair *arg2 = 0 ;
9357   bool result;
9358
9359   arg1 = (Dali::Uint16Pair *)jarg1;
9360   arg2 = (Dali::Uint16Pair *)jarg2;
9361   if (!arg2) {
9362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9363     return 0;
9364   }
9365   {
9366     try {
9367       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9368     } catch (std::out_of_range& e) {
9369       {
9370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9371       };
9372     } catch (std::exception& e) {
9373       {
9374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9375       };
9376     } catch (Dali::DaliException e) {
9377       {
9378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9379       };
9380     } catch (...) {
9381       {
9382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9383       };
9384     }
9385   }
9386
9387   jresult = result;
9388   return jresult;
9389 }
9390
9391
9392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9393   unsigned int jresult ;
9394   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9395   Dali::Uint16Pair *arg2 = 0 ;
9396   bool result;
9397
9398   arg1 = (Dali::Uint16Pair *)jarg1;
9399   arg2 = (Dali::Uint16Pair *)jarg2;
9400   if (!arg2) {
9401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9402     return 0;
9403   }
9404   {
9405     try {
9406       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9407     } catch (std::out_of_range& e) {
9408       {
9409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9410       };
9411     } catch (std::exception& e) {
9412       {
9413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9414       };
9415     } catch (Dali::DaliException e) {
9416       {
9417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9418       };
9419     } catch (...) {
9420       {
9421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9422       };
9423     }
9424   }
9425
9426   jresult = result;
9427   return jresult;
9428 }
9429
9430
9431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9432   unsigned int jresult ;
9433   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9434   Dali::Uint16Pair *arg2 = 0 ;
9435   bool result;
9436
9437   arg1 = (Dali::Uint16Pair *)jarg1;
9438   arg2 = (Dali::Uint16Pair *)jarg2;
9439   if (!arg2) {
9440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9441     return 0;
9442   }
9443   {
9444     try {
9445       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9446     } catch (std::out_of_range& e) {
9447       {
9448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9449       };
9450     } catch (std::exception& e) {
9451       {
9452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9453       };
9454     } catch (Dali::DaliException e) {
9455       {
9456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9457       };
9458     } catch (...) {
9459       {
9460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9461       };
9462     }
9463   }
9464
9465   jresult = result;
9466   return jresult;
9467 }
9468
9469
9470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9471   unsigned int jresult ;
9472   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9473   Dali::Uint16Pair *arg2 = 0 ;
9474   bool result;
9475
9476   arg1 = (Dali::Uint16Pair *)jarg1;
9477   arg2 = (Dali::Uint16Pair *)jarg2;
9478   if (!arg2) {
9479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9480     return 0;
9481   }
9482   {
9483     try {
9484       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9485     } catch (std::out_of_range& e) {
9486       {
9487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9488       };
9489     } catch (std::exception& e) {
9490       {
9491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9492       };
9493     } catch (Dali::DaliException e) {
9494       {
9495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9496       };
9497     } catch (...) {
9498       {
9499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9500       };
9501     }
9502   }
9503
9504   jresult = result;
9505   return jresult;
9506 }
9507
9508
9509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9510   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9511
9512   arg1 = (Dali::Uint16Pair *)jarg1;
9513   {
9514     try {
9515       delete arg1;
9516     } catch (std::out_of_range& e) {
9517       {
9518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9519       };
9520     } catch (std::exception& e) {
9521       {
9522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9523       };
9524     } catch (Dali::DaliException e) {
9525       {
9526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9527       };
9528     } catch (...) {
9529       {
9530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9531       };
9532     }
9533   }
9534
9535 }
9536
9537
9538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9539   void * jresult ;
9540   Dali::Degree *result = 0 ;
9541
9542   {
9543     try {
9544       result = (Dali::Degree *)new Dali::Degree();
9545     } catch (std::out_of_range& e) {
9546       {
9547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9548       };
9549     } catch (std::exception& e) {
9550       {
9551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9552       };
9553     } catch (Dali::DaliException e) {
9554       {
9555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9556       };
9557     } catch (...) {
9558       {
9559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9560       };
9561     }
9562   }
9563
9564   jresult = (void *)result;
9565   return jresult;
9566 }
9567
9568
9569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9570   void * jresult ;
9571   float arg1 ;
9572   Dali::Degree *result = 0 ;
9573
9574   arg1 = (float)jarg1;
9575   {
9576     try {
9577       result = (Dali::Degree *)new Dali::Degree(arg1);
9578     } catch (std::out_of_range& e) {
9579       {
9580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9581       };
9582     } catch (std::exception& e) {
9583       {
9584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9585       };
9586     } catch (Dali::DaliException e) {
9587       {
9588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9589       };
9590     } catch (...) {
9591       {
9592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9593       };
9594     }
9595   }
9596
9597   jresult = (void *)result;
9598   return jresult;
9599 }
9600
9601
9602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9603   void * jresult ;
9604   Dali::Radian arg1 ;
9605   Dali::Radian *argp1 ;
9606   Dali::Degree *result = 0 ;
9607
9608   argp1 = (Dali::Radian *)jarg1;
9609   if (!argp1) {
9610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9611     return 0;
9612   }
9613   arg1 = *argp1;
9614   {
9615     try {
9616       result = (Dali::Degree *)new Dali::Degree(arg1);
9617     } catch (std::out_of_range& e) {
9618       {
9619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9620       };
9621     } catch (std::exception& e) {
9622       {
9623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9624       };
9625     } catch (Dali::DaliException e) {
9626       {
9627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9628       };
9629     } catch (...) {
9630       {
9631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9632       };
9633     }
9634   }
9635
9636   jresult = (void *)result;
9637   return jresult;
9638 }
9639
9640
9641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9642   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9643   float arg2 ;
9644
9645   arg1 = (Dali::Degree *)jarg1;
9646   arg2 = (float)jarg2;
9647   if (arg1) (arg1)->degree = arg2;
9648 }
9649
9650
9651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9652   float jresult ;
9653   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9654   float result;
9655
9656   arg1 = (Dali::Degree *)jarg1;
9657   result = (float) ((arg1)->degree);
9658   jresult = result;
9659   return jresult;
9660 }
9661
9662
9663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9664   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9665
9666   arg1 = (Dali::Degree *)jarg1;
9667   {
9668     try {
9669       delete arg1;
9670     } catch (std::out_of_range& e) {
9671       {
9672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9673       };
9674     } catch (std::exception& e) {
9675       {
9676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9677       };
9678     } catch (Dali::DaliException e) {
9679       {
9680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9681       };
9682     } catch (...) {
9683       {
9684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9685       };
9686     }
9687   }
9688
9689 }
9690
9691
9692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9693   void * jresult ;
9694   Dali::Radian *result = 0 ;
9695
9696   result = (Dali::Radian *)&Dali::ANGLE_360;
9697   jresult = (void *)result;
9698   return jresult;
9699 }
9700
9701
9702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9703   void * jresult ;
9704   Dali::Radian *result = 0 ;
9705
9706   result = (Dali::Radian *)&Dali::ANGLE_315;
9707   jresult = (void *)result;
9708   return jresult;
9709 }
9710
9711
9712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9713   void * jresult ;
9714   Dali::Radian *result = 0 ;
9715
9716   result = (Dali::Radian *)&Dali::ANGLE_270;
9717   jresult = (void *)result;
9718   return jresult;
9719 }
9720
9721
9722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9723   void * jresult ;
9724   Dali::Radian *result = 0 ;
9725
9726   result = (Dali::Radian *)&Dali::ANGLE_225;
9727   jresult = (void *)result;
9728   return jresult;
9729 }
9730
9731
9732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9733   void * jresult ;
9734   Dali::Radian *result = 0 ;
9735
9736   result = (Dali::Radian *)&Dali::ANGLE_180;
9737   jresult = (void *)result;
9738   return jresult;
9739 }
9740
9741
9742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9743   void * jresult ;
9744   Dali::Radian *result = 0 ;
9745
9746   result = (Dali::Radian *)&Dali::ANGLE_135;
9747   jresult = (void *)result;
9748   return jresult;
9749 }
9750
9751
9752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9753   void * jresult ;
9754   Dali::Radian *result = 0 ;
9755
9756   result = (Dali::Radian *)&Dali::ANGLE_120;
9757   jresult = (void *)result;
9758   return jresult;
9759 }
9760
9761
9762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9763   void * jresult ;
9764   Dali::Radian *result = 0 ;
9765
9766   result = (Dali::Radian *)&Dali::ANGLE_90;
9767   jresult = (void *)result;
9768   return jresult;
9769 }
9770
9771
9772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9773   void * jresult ;
9774   Dali::Radian *result = 0 ;
9775
9776   result = (Dali::Radian *)&Dali::ANGLE_60;
9777   jresult = (void *)result;
9778   return jresult;
9779 }
9780
9781
9782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9783   void * jresult ;
9784   Dali::Radian *result = 0 ;
9785
9786   result = (Dali::Radian *)&Dali::ANGLE_45;
9787   jresult = (void *)result;
9788   return jresult;
9789 }
9790
9791
9792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9793   void * jresult ;
9794   Dali::Radian *result = 0 ;
9795
9796   result = (Dali::Radian *)&Dali::ANGLE_30;
9797   jresult = (void *)result;
9798   return jresult;
9799 }
9800
9801
9802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9803   void * jresult ;
9804   Dali::Radian *result = 0 ;
9805
9806   result = (Dali::Radian *)&Dali::ANGLE_0;
9807   jresult = (void *)result;
9808   return jresult;
9809 }
9810
9811
9812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9813   unsigned int jresult ;
9814   Dali::Degree *arg1 = 0 ;
9815   Dali::Degree *arg2 = 0 ;
9816   bool result;
9817
9818   arg1 = (Dali::Degree *)jarg1;
9819   if (!arg1) {
9820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9821     return 0;
9822   }
9823   arg2 = (Dali::Degree *)jarg2;
9824   if (!arg2) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9826     return 0;
9827   }
9828   {
9829     try {
9830       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9831     } catch (std::out_of_range& e) {
9832       {
9833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9834       };
9835     } catch (std::exception& e) {
9836       {
9837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9838       };
9839     } catch (Dali::DaliException e) {
9840       {
9841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9842       };
9843     } catch (...) {
9844       {
9845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9846       };
9847     }
9848   }
9849
9850   jresult = result;
9851   return jresult;
9852 }
9853
9854
9855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9856   unsigned int jresult ;
9857   Dali::Degree *arg1 = 0 ;
9858   Dali::Degree *arg2 = 0 ;
9859   bool result;
9860
9861   arg1 = (Dali::Degree *)jarg1;
9862   if (!arg1) {
9863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9864     return 0;
9865   }
9866   arg2 = (Dali::Degree *)jarg2;
9867   if (!arg2) {
9868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9869     return 0;
9870   }
9871   {
9872     try {
9873       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9874     } catch (std::out_of_range& e) {
9875       {
9876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9877       };
9878     } catch (std::exception& e) {
9879       {
9880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9881       };
9882     } catch (Dali::DaliException e) {
9883       {
9884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9885       };
9886     } catch (...) {
9887       {
9888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9889       };
9890     }
9891   }
9892
9893   jresult = result;
9894   return jresult;
9895 }
9896
9897
9898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9899   void * jresult ;
9900   Dali::Degree arg1 ;
9901   float arg2 ;
9902   float arg3 ;
9903   Dali::Degree *argp1 ;
9904   Dali::Degree result;
9905
9906   argp1 = (Dali::Degree *)jarg1;
9907   if (!argp1) {
9908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9909     return 0;
9910   }
9911   arg1 = *argp1;
9912   arg2 = (float)jarg2;
9913   arg3 = (float)jarg3;
9914   {
9915     try {
9916       result = Dali::Clamp(arg1,arg2,arg3);
9917     } catch (std::out_of_range& e) {
9918       {
9919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9920       };
9921     } catch (std::exception& e) {
9922       {
9923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9924       };
9925     } catch (Dali::DaliException e) {
9926       {
9927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9928       };
9929     } catch (...) {
9930       {
9931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9932       };
9933     }
9934   }
9935
9936   jresult = new Dali::Degree((const Dali::Degree &)result);
9937   return jresult;
9938 }
9939
9940
9941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9942   void * jresult ;
9943   Dali::Radian *result = 0 ;
9944
9945   {
9946     try {
9947       result = (Dali::Radian *)new Dali::Radian();
9948     } catch (std::out_of_range& e) {
9949       {
9950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9951       };
9952     } catch (std::exception& e) {
9953       {
9954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9955       };
9956     } catch (Dali::DaliException e) {
9957       {
9958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9959       };
9960     } catch (...) {
9961       {
9962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9963       };
9964     }
9965   }
9966
9967   jresult = (void *)result;
9968   return jresult;
9969 }
9970
9971
9972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9973   void * jresult ;
9974   float arg1 ;
9975   Dali::Radian *result = 0 ;
9976
9977   arg1 = (float)jarg1;
9978   {
9979     try {
9980       result = (Dali::Radian *)new Dali::Radian(arg1);
9981     } catch (std::out_of_range& e) {
9982       {
9983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9984       };
9985     } catch (std::exception& e) {
9986       {
9987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9988       };
9989     } catch (Dali::DaliException e) {
9990       {
9991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9992       };
9993     } catch (...) {
9994       {
9995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9996       };
9997     }
9998   }
9999
10000   jresult = (void *)result;
10001   return jresult;
10002 }
10003
10004
10005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10006   void * jresult ;
10007   Dali::Degree arg1 ;
10008   Dali::Degree *argp1 ;
10009   Dali::Radian *result = 0 ;
10010
10011   argp1 = (Dali::Degree *)jarg1;
10012   if (!argp1) {
10013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10014     return 0;
10015   }
10016   arg1 = *argp1;
10017   {
10018     try {
10019       result = (Dali::Radian *)new Dali::Radian(arg1);
10020     } catch (std::out_of_range& e) {
10021       {
10022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10023       };
10024     } catch (std::exception& e) {
10025       {
10026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10027       };
10028     } catch (Dali::DaliException e) {
10029       {
10030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10031       };
10032     } catch (...) {
10033       {
10034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10035       };
10036     }
10037   }
10038
10039   jresult = (void *)result;
10040   return jresult;
10041 }
10042
10043
10044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10045   void * jresult ;
10046   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10047   float arg2 ;
10048   Dali::Radian *result = 0 ;
10049
10050   arg1 = (Dali::Radian *)jarg1;
10051   arg2 = (float)jarg2;
10052   {
10053     try {
10054       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10055     } catch (std::out_of_range& e) {
10056       {
10057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10058       };
10059     } catch (std::exception& e) {
10060       {
10061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10062       };
10063     } catch (Dali::DaliException e) {
10064       {
10065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10066       };
10067     } catch (...) {
10068       {
10069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10070       };
10071     }
10072   }
10073
10074   jresult = (void *)result;
10075   return jresult;
10076 }
10077
10078
10079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10080   void * jresult ;
10081   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10082   Dali::Degree arg2 ;
10083   Dali::Degree *argp2 ;
10084   Dali::Radian *result = 0 ;
10085
10086   arg1 = (Dali::Radian *)jarg1;
10087   argp2 = (Dali::Degree *)jarg2;
10088   if (!argp2) {
10089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10090     return 0;
10091   }
10092   arg2 = *argp2;
10093   {
10094     try {
10095       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10096     } catch (std::out_of_range& e) {
10097       {
10098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10099       };
10100     } catch (std::exception& e) {
10101       {
10102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10103       };
10104     } catch (Dali::DaliException e) {
10105       {
10106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10107       };
10108     } catch (...) {
10109       {
10110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10111       };
10112     }
10113   }
10114
10115   jresult = (void *)result;
10116   return jresult;
10117 }
10118
10119
10120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10121   float jresult ;
10122   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10123   float result;
10124
10125   arg1 = (Dali::Radian *)jarg1;
10126   {
10127     try {
10128       result = (float)((Dali::Radian const *)arg1)->operator float();
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 (Dali::DaliException e) {
10138       {
10139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10140       };
10141     } catch (...) {
10142       {
10143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10144       };
10145     }
10146   }
10147
10148   jresult = result;
10149   return jresult;
10150 }
10151
10152
10153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10154   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10155   float arg2 ;
10156
10157   arg1 = (Dali::Radian *)jarg1;
10158   arg2 = (float)jarg2;
10159   if (arg1) (arg1)->radian = arg2;
10160 }
10161
10162
10163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10164   float jresult ;
10165   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10166   float result;
10167
10168   arg1 = (Dali::Radian *)jarg1;
10169   result = (float) ((arg1)->radian);
10170   jresult = result;
10171   return jresult;
10172 }
10173
10174
10175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10176   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10177
10178   arg1 = (Dali::Radian *)jarg1;
10179   {
10180     try {
10181       delete arg1;
10182     } catch (std::out_of_range& e) {
10183       {
10184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10185       };
10186     } catch (std::exception& e) {
10187       {
10188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10189       };
10190     } catch (Dali::DaliException e) {
10191       {
10192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10193       };
10194     } catch (...) {
10195       {
10196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10197       };
10198     }
10199   }
10200
10201 }
10202
10203
10204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10205   unsigned int jresult ;
10206   Dali::Radian arg1 ;
10207   Dali::Radian arg2 ;
10208   Dali::Radian *argp1 ;
10209   Dali::Radian *argp2 ;
10210   bool result;
10211
10212   argp1 = (Dali::Radian *)jarg1;
10213   if (!argp1) {
10214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10215     return 0;
10216   }
10217   arg1 = *argp1;
10218   argp2 = (Dali::Radian *)jarg2;
10219   if (!argp2) {
10220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10221     return 0;
10222   }
10223   arg2 = *argp2;
10224   {
10225     try {
10226       result = (bool)Dali::operator ==(arg1,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 (Dali::DaliException e) {
10236       {
10237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10238       };
10239     } catch (...) {
10240       {
10241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10242       };
10243     }
10244   }
10245
10246   jresult = result;
10247   return jresult;
10248 }
10249
10250
10251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10252   unsigned int jresult ;
10253   Dali::Radian arg1 ;
10254   Dali::Radian arg2 ;
10255   Dali::Radian *argp1 ;
10256   Dali::Radian *argp2 ;
10257   bool result;
10258
10259   argp1 = (Dali::Radian *)jarg1;
10260   if (!argp1) {
10261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10262     return 0;
10263   }
10264   arg1 = *argp1;
10265   argp2 = (Dali::Radian *)jarg2;
10266   if (!argp2) {
10267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10268     return 0;
10269   }
10270   arg2 = *argp2;
10271   {
10272     try {
10273       result = (bool)Dali::operator !=(arg1,arg2);
10274     } catch (std::out_of_range& e) {
10275       {
10276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10277       };
10278     } catch (std::exception& e) {
10279       {
10280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10281       };
10282     } catch (Dali::DaliException e) {
10283       {
10284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10285       };
10286     } catch (...) {
10287       {
10288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10289       };
10290     }
10291   }
10292
10293   jresult = result;
10294   return jresult;
10295 }
10296
10297
10298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10299   unsigned int jresult ;
10300   Dali::Radian arg1 ;
10301   Dali::Degree arg2 ;
10302   Dali::Radian *argp1 ;
10303   Dali::Degree *argp2 ;
10304   bool result;
10305
10306   argp1 = (Dali::Radian *)jarg1;
10307   if (!argp1) {
10308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10309     return 0;
10310   }
10311   arg1 = *argp1;
10312   argp2 = (Dali::Degree *)jarg2;
10313   if (!argp2) {
10314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10315     return 0;
10316   }
10317   arg2 = *argp2;
10318   {
10319     try {
10320       result = (bool)Dali::operator ==(arg1,arg2);
10321     } catch (std::out_of_range& e) {
10322       {
10323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10324       };
10325     } catch (std::exception& e) {
10326       {
10327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10328       };
10329     } catch (Dali::DaliException e) {
10330       {
10331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10332       };
10333     } catch (...) {
10334       {
10335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10336       };
10337     }
10338   }
10339
10340   jresult = result;
10341   return jresult;
10342 }
10343
10344
10345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10346   unsigned int jresult ;
10347   Dali::Radian arg1 ;
10348   Dali::Degree arg2 ;
10349   Dali::Radian *argp1 ;
10350   Dali::Degree *argp2 ;
10351   bool result;
10352
10353   argp1 = (Dali::Radian *)jarg1;
10354   if (!argp1) {
10355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10356     return 0;
10357   }
10358   arg1 = *argp1;
10359   argp2 = (Dali::Degree *)jarg2;
10360   if (!argp2) {
10361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10362     return 0;
10363   }
10364   arg2 = *argp2;
10365   {
10366     try {
10367       result = (bool)Dali::operator !=(arg1,arg2);
10368     } catch (std::out_of_range& e) {
10369       {
10370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10371       };
10372     } catch (std::exception& e) {
10373       {
10374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10375       };
10376     } catch (Dali::DaliException e) {
10377       {
10378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10379       };
10380     } catch (...) {
10381       {
10382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10383       };
10384     }
10385   }
10386
10387   jresult = result;
10388   return jresult;
10389 }
10390
10391
10392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10393   unsigned int jresult ;
10394   Dali::Degree arg1 ;
10395   Dali::Radian arg2 ;
10396   Dali::Degree *argp1 ;
10397   Dali::Radian *argp2 ;
10398   bool result;
10399
10400   argp1 = (Dali::Degree *)jarg1;
10401   if (!argp1) {
10402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10403     return 0;
10404   }
10405   arg1 = *argp1;
10406   argp2 = (Dali::Radian *)jarg2;
10407   if (!argp2) {
10408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10409     return 0;
10410   }
10411   arg2 = *argp2;
10412   {
10413     try {
10414       result = (bool)Dali::operator ==(arg1,arg2);
10415     } catch (std::out_of_range& e) {
10416       {
10417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10418       };
10419     } catch (std::exception& e) {
10420       {
10421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10422       };
10423     } catch (Dali::DaliException e) {
10424       {
10425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10426       };
10427     } catch (...) {
10428       {
10429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10430       };
10431     }
10432   }
10433
10434   jresult = result;
10435   return jresult;
10436 }
10437
10438
10439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10440   unsigned int jresult ;
10441   Dali::Degree arg1 ;
10442   Dali::Radian arg2 ;
10443   Dali::Degree *argp1 ;
10444   Dali::Radian *argp2 ;
10445   bool result;
10446
10447   argp1 = (Dali::Degree *)jarg1;
10448   if (!argp1) {
10449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10450     return 0;
10451   }
10452   arg1 = *argp1;
10453   argp2 = (Dali::Radian *)jarg2;
10454   if (!argp2) {
10455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10456     return 0;
10457   }
10458   arg2 = *argp2;
10459   {
10460     try {
10461       result = (bool)Dali::operator !=(arg1,arg2);
10462     } catch (std::out_of_range& e) {
10463       {
10464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10465       };
10466     } catch (std::exception& e) {
10467       {
10468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10469       };
10470     } catch (Dali::DaliException e) {
10471       {
10472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10473       };
10474     } catch (...) {
10475       {
10476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10477       };
10478     }
10479   }
10480
10481   jresult = result;
10482   return jresult;
10483 }
10484
10485
10486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10487   unsigned int jresult ;
10488   Dali::Radian arg1 ;
10489   Dali::Radian arg2 ;
10490   Dali::Radian *argp1 ;
10491   Dali::Radian *argp2 ;
10492   bool result;
10493
10494   argp1 = (Dali::Radian *)jarg1;
10495   if (!argp1) {
10496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10497     return 0;
10498   }
10499   arg1 = *argp1;
10500   argp2 = (Dali::Radian *)jarg2;
10501   if (!argp2) {
10502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10503     return 0;
10504   }
10505   arg2 = *argp2;
10506   {
10507     try {
10508       result = (bool)Dali::operator >(arg1,arg2);
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 (Dali::DaliException e) {
10518       {
10519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10520       };
10521     } catch (...) {
10522       {
10523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10524       };
10525     }
10526   }
10527
10528   jresult = result;
10529   return jresult;
10530 }
10531
10532
10533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10534   unsigned int jresult ;
10535   Dali::Radian arg1 ;
10536   Dali::Degree arg2 ;
10537   Dali::Radian *argp1 ;
10538   Dali::Degree *argp2 ;
10539   bool result;
10540
10541   argp1 = (Dali::Radian *)jarg1;
10542   if (!argp1) {
10543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10544     return 0;
10545   }
10546   arg1 = *argp1;
10547   argp2 = (Dali::Degree *)jarg2;
10548   if (!argp2) {
10549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10550     return 0;
10551   }
10552   arg2 = *argp2;
10553   {
10554     try {
10555       result = (bool)Dali::operator >(arg1,arg2);
10556     } catch (std::out_of_range& e) {
10557       {
10558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10559       };
10560     } catch (std::exception& e) {
10561       {
10562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10563       };
10564     } catch (Dali::DaliException e) {
10565       {
10566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10567       };
10568     } catch (...) {
10569       {
10570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10571       };
10572     }
10573   }
10574
10575   jresult = result;
10576   return jresult;
10577 }
10578
10579
10580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10581   unsigned int jresult ;
10582   Dali::Degree arg1 ;
10583   Dali::Radian arg2 ;
10584   Dali::Degree *argp1 ;
10585   Dali::Radian *argp2 ;
10586   bool result;
10587
10588   argp1 = (Dali::Degree *)jarg1;
10589   if (!argp1) {
10590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10591     return 0;
10592   }
10593   arg1 = *argp1;
10594   argp2 = (Dali::Radian *)jarg2;
10595   if (!argp2) {
10596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10597     return 0;
10598   }
10599   arg2 = *argp2;
10600   {
10601     try {
10602       result = (bool)Dali::operator >(arg1,arg2);
10603     } catch (std::out_of_range& e) {
10604       {
10605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10606       };
10607     } catch (std::exception& e) {
10608       {
10609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10610       };
10611     } catch (Dali::DaliException e) {
10612       {
10613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10614       };
10615     } catch (...) {
10616       {
10617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10618       };
10619     }
10620   }
10621
10622   jresult = result;
10623   return jresult;
10624 }
10625
10626
10627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10628   unsigned int jresult ;
10629   Dali::Radian arg1 ;
10630   Dali::Radian arg2 ;
10631   Dali::Radian *argp1 ;
10632   Dali::Radian *argp2 ;
10633   bool result;
10634
10635   argp1 = (Dali::Radian *)jarg1;
10636   if (!argp1) {
10637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10638     return 0;
10639   }
10640   arg1 = *argp1;
10641   argp2 = (Dali::Radian *)jarg2;
10642   if (!argp2) {
10643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10644     return 0;
10645   }
10646   arg2 = *argp2;
10647   {
10648     try {
10649       result = (bool)Dali::operator <(arg1,arg2);
10650     } catch (std::out_of_range& e) {
10651       {
10652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10653       };
10654     } catch (std::exception& e) {
10655       {
10656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10657       };
10658     } catch (Dali::DaliException e) {
10659       {
10660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10661       };
10662     } catch (...) {
10663       {
10664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10665       };
10666     }
10667   }
10668
10669   jresult = result;
10670   return jresult;
10671 }
10672
10673
10674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10675   unsigned int jresult ;
10676   Dali::Radian arg1 ;
10677   Dali::Degree arg2 ;
10678   Dali::Radian *argp1 ;
10679   Dali::Degree *argp2 ;
10680   bool result;
10681
10682   argp1 = (Dali::Radian *)jarg1;
10683   if (!argp1) {
10684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10685     return 0;
10686   }
10687   arg1 = *argp1;
10688   argp2 = (Dali::Degree *)jarg2;
10689   if (!argp2) {
10690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10691     return 0;
10692   }
10693   arg2 = *argp2;
10694   {
10695     try {
10696       result = (bool)Dali::operator <(arg1,arg2);
10697     } catch (std::out_of_range& e) {
10698       {
10699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10700       };
10701     } catch (std::exception& e) {
10702       {
10703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10704       };
10705     } catch (Dali::DaliException e) {
10706       {
10707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10708       };
10709     } catch (...) {
10710       {
10711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10712       };
10713     }
10714   }
10715
10716   jresult = result;
10717   return jresult;
10718 }
10719
10720
10721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10722   unsigned int jresult ;
10723   Dali::Degree arg1 ;
10724   Dali::Radian arg2 ;
10725   Dali::Degree *argp1 ;
10726   Dali::Radian *argp2 ;
10727   bool result;
10728
10729   argp1 = (Dali::Degree *)jarg1;
10730   if (!argp1) {
10731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10732     return 0;
10733   }
10734   arg1 = *argp1;
10735   argp2 = (Dali::Radian *)jarg2;
10736   if (!argp2) {
10737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10738     return 0;
10739   }
10740   arg2 = *argp2;
10741   {
10742     try {
10743       result = (bool)Dali::operator <(arg1,arg2);
10744     } catch (std::out_of_range& e) {
10745       {
10746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10747       };
10748     } catch (std::exception& e) {
10749       {
10750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10751       };
10752     } catch (Dali::DaliException e) {
10753       {
10754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10755       };
10756     } catch (...) {
10757       {
10758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10759       };
10760     }
10761   }
10762
10763   jresult = result;
10764   return jresult;
10765 }
10766
10767
10768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10769   void * jresult ;
10770   Dali::Radian arg1 ;
10771   float arg2 ;
10772   Dali::Radian *argp1 ;
10773   Dali::Radian result;
10774
10775   argp1 = (Dali::Radian *)jarg1;
10776   if (!argp1) {
10777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10778     return 0;
10779   }
10780   arg1 = *argp1;
10781   arg2 = (float)jarg2;
10782   {
10783     try {
10784       result = Dali::operator *(arg1,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 (Dali::DaliException e) {
10794       {
10795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10796       };
10797     } catch (...) {
10798       {
10799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10800       };
10801     }
10802   }
10803
10804   jresult = new Dali::Radian((const Dali::Radian &)result);
10805   return jresult;
10806 }
10807
10808
10809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10810   void * jresult ;
10811   Dali::Radian arg1 ;
10812   Dali::Radian *argp1 ;
10813   Dali::Radian result;
10814
10815   argp1 = (Dali::Radian *)jarg1;
10816   if (!argp1) {
10817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10818     return 0;
10819   }
10820   arg1 = *argp1;
10821   {
10822     try {
10823       result = Dali::operator -(arg1);
10824     } catch (std::out_of_range& e) {
10825       {
10826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10827       };
10828     } catch (std::exception& e) {
10829       {
10830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10831       };
10832     } catch (Dali::DaliException e) {
10833       {
10834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10835       };
10836     } catch (...) {
10837       {
10838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10839       };
10840     }
10841   }
10842
10843   jresult = new Dali::Radian((const Dali::Radian &)result);
10844   return jresult;
10845 }
10846
10847
10848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10849   void * jresult ;
10850   Dali::Radian arg1 ;
10851   float arg2 ;
10852   float arg3 ;
10853   Dali::Radian *argp1 ;
10854   Dali::Radian result;
10855
10856   argp1 = (Dali::Radian *)jarg1;
10857   if (!argp1) {
10858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10859     return 0;
10860   }
10861   arg1 = *argp1;
10862   arg2 = (float)jarg2;
10863   arg3 = (float)jarg3;
10864   {
10865     try {
10866       result = Dali::Clamp(arg1,arg2,arg3);
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 (Dali::DaliException e) {
10876       {
10877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10878       };
10879     } catch (...) {
10880       {
10881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10882       };
10883     }
10884   }
10885
10886   jresult = new Dali::Radian((const Dali::Radian &)result);
10887   return jresult;
10888 }
10889
10890
10891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10892   void * jresult ;
10893   Dali::Quaternion *result = 0 ;
10894
10895   {
10896     try {
10897       result = (Dali::Quaternion *)new Dali::Quaternion();
10898     } catch (std::out_of_range& e) {
10899       {
10900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10901       };
10902     } catch (std::exception& e) {
10903       {
10904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10905       };
10906     } catch (Dali::DaliException e) {
10907       {
10908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10909       };
10910     } catch (...) {
10911       {
10912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10913       };
10914     }
10915   }
10916
10917   jresult = (void *)result;
10918   return jresult;
10919 }
10920
10921
10922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10923   void * jresult ;
10924   Dali::Radian arg1 ;
10925   Dali::Vector3 *arg2 = 0 ;
10926   Dali::Radian *argp1 ;
10927   Dali::Quaternion *result = 0 ;
10928
10929   argp1 = (Dali::Radian *)jarg1;
10930   if (!argp1) {
10931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10932     return 0;
10933   }
10934   arg1 = *argp1;
10935   arg2 = (Dali::Vector3 *)jarg2;
10936   if (!arg2) {
10937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10938     return 0;
10939   }
10940   {
10941     try {
10942       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10943     } catch (std::out_of_range& e) {
10944       {
10945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10946       };
10947     } catch (std::exception& e) {
10948       {
10949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10950       };
10951     } catch (Dali::DaliException e) {
10952       {
10953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10954       };
10955     } catch (...) {
10956       {
10957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10958       };
10959     }
10960   }
10961
10962   jresult = (void *)result;
10963   return jresult;
10964 }
10965
10966
10967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10968   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10969
10970   arg1 = (Dali::Quaternion *)jarg1;
10971   {
10972     try {
10973       delete arg1;
10974     } catch (std::out_of_range& e) {
10975       {
10976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10977       };
10978     } catch (std::exception& e) {
10979       {
10980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10981       };
10982     } catch (Dali::DaliException e) {
10983       {
10984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10985       };
10986     } catch (...) {
10987       {
10988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10989       };
10990     }
10991   }
10992
10993 }
10994
10995
10996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10997   void * jresult ;
10998   Dali::Quaternion *result = 0 ;
10999
11000   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11001   jresult = (void *)result;
11002   return jresult;
11003 }
11004
11005
11006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11007   unsigned int jresult ;
11008   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11009   bool result;
11010
11011   arg1 = (Dali::Quaternion *)jarg1;
11012   {
11013     try {
11014       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11015     } catch (std::out_of_range& e) {
11016       {
11017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11018       };
11019     } catch (std::exception& e) {
11020       {
11021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11022       };
11023     } catch (Dali::DaliException e) {
11024       {
11025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11026       };
11027     } catch (...) {
11028       {
11029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11030       };
11031     }
11032   }
11033
11034   jresult = result;
11035   return jresult;
11036 }
11037
11038
11039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11040   unsigned int jresult ;
11041   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11042   Dali::Vector3 *arg2 = 0 ;
11043   Dali::Radian *arg3 = 0 ;
11044   bool result;
11045
11046   arg1 = (Dali::Quaternion *)jarg1;
11047   arg2 = (Dali::Vector3 *)jarg2;
11048   if (!arg2) {
11049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11050     return 0;
11051   }
11052   arg3 = (Dali::Radian *)jarg3;
11053   if (!arg3) {
11054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11055     return 0;
11056   }
11057   {
11058     try {
11059       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11060     } catch (std::out_of_range& e) {
11061       {
11062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11063       };
11064     } catch (std::exception& e) {
11065       {
11066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11067       };
11068     } catch (Dali::DaliException e) {
11069       {
11070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11071       };
11072     } catch (...) {
11073       {
11074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11075       };
11076     }
11077   }
11078
11079   jresult = result;
11080   return jresult;
11081 }
11082
11083
11084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11085   void * jresult ;
11086   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11087   Dali::Quaternion *arg2 = 0 ;
11088   Dali::Quaternion result;
11089
11090   arg1 = (Dali::Quaternion *)jarg1;
11091   arg2 = (Dali::Quaternion *)jarg2;
11092   if (!arg2) {
11093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11094     return 0;
11095   }
11096   {
11097     try {
11098       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11099     } catch (std::out_of_range& e) {
11100       {
11101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11102       };
11103     } catch (std::exception& e) {
11104       {
11105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11106       };
11107     } catch (Dali::DaliException e) {
11108       {
11109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11110       };
11111     } catch (...) {
11112       {
11113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11114       };
11115     }
11116   }
11117
11118   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11119   return jresult;
11120 }
11121
11122
11123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11124   void * jresult ;
11125   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11126   Dali::Quaternion *arg2 = 0 ;
11127   Dali::Quaternion result;
11128
11129   arg1 = (Dali::Quaternion *)jarg1;
11130   arg2 = (Dali::Quaternion *)jarg2;
11131   if (!arg2) {
11132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11133     return 0;
11134   }
11135   {
11136     try {
11137       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11138     } catch (std::out_of_range& e) {
11139       {
11140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11141       };
11142     } catch (std::exception& e) {
11143       {
11144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11145       };
11146     } catch (Dali::DaliException e) {
11147       {
11148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11149       };
11150     } catch (...) {
11151       {
11152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11153       };
11154     }
11155   }
11156
11157   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11158   return jresult;
11159 }
11160
11161
11162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11163   void * jresult ;
11164   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11165   Dali::Quaternion *arg2 = 0 ;
11166   Dali::Quaternion result;
11167
11168   arg1 = (Dali::Quaternion *)jarg1;
11169   arg2 = (Dali::Quaternion *)jarg2;
11170   if (!arg2) {
11171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11172     return 0;
11173   }
11174   {
11175     try {
11176       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11177     } catch (std::out_of_range& e) {
11178       {
11179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11180       };
11181     } catch (std::exception& e) {
11182       {
11183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11184       };
11185     } catch (Dali::DaliException e) {
11186       {
11187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11188       };
11189     } catch (...) {
11190       {
11191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11192       };
11193     }
11194   }
11195
11196   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11197   return jresult;
11198 }
11199
11200
11201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11202   void * jresult ;
11203   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11204   Dali::Vector3 *arg2 = 0 ;
11205   Dali::Vector3 result;
11206
11207   arg1 = (Dali::Quaternion *)jarg1;
11208   arg2 = (Dali::Vector3 *)jarg2;
11209   if (!arg2) {
11210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11211     return 0;
11212   }
11213   {
11214     try {
11215       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11216     } catch (std::out_of_range& e) {
11217       {
11218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11219       };
11220     } catch (std::exception& e) {
11221       {
11222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11223       };
11224     } catch (Dali::DaliException e) {
11225       {
11226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11227       };
11228     } catch (...) {
11229       {
11230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11231       };
11232     }
11233   }
11234
11235   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11236   return jresult;
11237 }
11238
11239
11240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11241   void * jresult ;
11242   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11243   Dali::Quaternion *arg2 = 0 ;
11244   Dali::Quaternion result;
11245
11246   arg1 = (Dali::Quaternion *)jarg1;
11247   arg2 = (Dali::Quaternion *)jarg2;
11248   if (!arg2) {
11249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11250     return 0;
11251   }
11252   {
11253     try {
11254       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11255     } catch (std::out_of_range& e) {
11256       {
11257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11258       };
11259     } catch (std::exception& e) {
11260       {
11261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11262       };
11263     } catch (Dali::DaliException e) {
11264       {
11265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11266       };
11267     } catch (...) {
11268       {
11269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11270       };
11271     }
11272   }
11273
11274   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11275   return jresult;
11276 }
11277
11278
11279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11280   void * jresult ;
11281   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11282   float arg2 ;
11283   Dali::Quaternion result;
11284
11285   arg1 = (Dali::Quaternion *)jarg1;
11286   arg2 = (float)jarg2;
11287   {
11288     try {
11289       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11290     } catch (std::out_of_range& e) {
11291       {
11292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11293       };
11294     } catch (std::exception& e) {
11295       {
11296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11297       };
11298     } catch (Dali::DaliException e) {
11299       {
11300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11301       };
11302     } catch (...) {
11303       {
11304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11305       };
11306     }
11307   }
11308
11309   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11310   return jresult;
11311 }
11312
11313
11314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11315   void * jresult ;
11316   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11317   float arg2 ;
11318   Dali::Quaternion result;
11319
11320   arg1 = (Dali::Quaternion *)jarg1;
11321   arg2 = (float)jarg2;
11322   {
11323     try {
11324       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11325     } catch (std::out_of_range& e) {
11326       {
11327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11328       };
11329     } catch (std::exception& e) {
11330       {
11331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11332       };
11333     } catch (Dali::DaliException e) {
11334       {
11335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11336       };
11337     } catch (...) {
11338       {
11339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11340       };
11341     }
11342   }
11343
11344   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11345   return jresult;
11346 }
11347
11348
11349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11350   void * jresult ;
11351   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11352   Dali::Quaternion result;
11353
11354   arg1 = (Dali::Quaternion *)jarg1;
11355   {
11356     try {
11357       result = ((Dali::Quaternion const *)arg1)->operator -();
11358     } catch (std::out_of_range& e) {
11359       {
11360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11361       };
11362     } catch (std::exception& e) {
11363       {
11364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11365       };
11366     } catch (Dali::DaliException e) {
11367       {
11368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11369       };
11370     } catch (...) {
11371       {
11372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11373       };
11374     }
11375   }
11376
11377   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11378   return jresult;
11379 }
11380
11381
11382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11383   void * jresult ;
11384   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11385   Dali::Quaternion *arg2 = 0 ;
11386   Dali::Quaternion *result = 0 ;
11387
11388   arg1 = (Dali::Quaternion *)jarg1;
11389   arg2 = (Dali::Quaternion *)jarg2;
11390   if (!arg2) {
11391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11392     return 0;
11393   }
11394   {
11395     try {
11396       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11397     } catch (std::out_of_range& e) {
11398       {
11399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11400       };
11401     } catch (std::exception& e) {
11402       {
11403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11404       };
11405     } catch (Dali::DaliException e) {
11406       {
11407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11408       };
11409     } catch (...) {
11410       {
11411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11412       };
11413     }
11414   }
11415
11416   jresult = (void *)result;
11417   return jresult;
11418 }
11419
11420
11421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11422   void * jresult ;
11423   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11424   Dali::Quaternion *arg2 = 0 ;
11425   Dali::Quaternion *result = 0 ;
11426
11427   arg1 = (Dali::Quaternion *)jarg1;
11428   arg2 = (Dali::Quaternion *)jarg2;
11429   if (!arg2) {
11430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11431     return 0;
11432   }
11433   {
11434     try {
11435       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11436     } catch (std::out_of_range& e) {
11437       {
11438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11439       };
11440     } catch (std::exception& e) {
11441       {
11442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11443       };
11444     } catch (Dali::DaliException e) {
11445       {
11446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11447       };
11448     } catch (...) {
11449       {
11450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11451       };
11452     }
11453   }
11454
11455   jresult = (void *)result;
11456   return jresult;
11457 }
11458
11459
11460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11461   void * jresult ;
11462   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11463   Dali::Quaternion *arg2 = 0 ;
11464   Dali::Quaternion *result = 0 ;
11465
11466   arg1 = (Dali::Quaternion *)jarg1;
11467   arg2 = (Dali::Quaternion *)jarg2;
11468   if (!arg2) {
11469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11470     return 0;
11471   }
11472   {
11473     try {
11474       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11475     } catch (std::out_of_range& e) {
11476       {
11477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11478       };
11479     } catch (std::exception& e) {
11480       {
11481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11482       };
11483     } catch (Dali::DaliException e) {
11484       {
11485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11486       };
11487     } catch (...) {
11488       {
11489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11490       };
11491     }
11492   }
11493
11494   jresult = (void *)result;
11495   return jresult;
11496 }
11497
11498
11499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11500   void * jresult ;
11501   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11502   float arg2 ;
11503   Dali::Quaternion *result = 0 ;
11504
11505   arg1 = (Dali::Quaternion *)jarg1;
11506   arg2 = (float)jarg2;
11507   {
11508     try {
11509       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11510     } catch (std::out_of_range& e) {
11511       {
11512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11513       };
11514     } catch (std::exception& e) {
11515       {
11516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11517       };
11518     } catch (Dali::DaliException e) {
11519       {
11520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11521       };
11522     } catch (...) {
11523       {
11524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11525       };
11526     }
11527   }
11528
11529   jresult = (void *)result;
11530   return jresult;
11531 }
11532
11533
11534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11535   void * jresult ;
11536   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11537   float arg2 ;
11538   Dali::Quaternion *result = 0 ;
11539
11540   arg1 = (Dali::Quaternion *)jarg1;
11541   arg2 = (float)jarg2;
11542   {
11543     try {
11544       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11545     } catch (std::out_of_range& e) {
11546       {
11547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11548       };
11549     } catch (std::exception& e) {
11550       {
11551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11552       };
11553     } catch (Dali::DaliException e) {
11554       {
11555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11556       };
11557     } catch (...) {
11558       {
11559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11560       };
11561     }
11562   }
11563
11564   jresult = (void *)result;
11565   return jresult;
11566 }
11567
11568
11569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11570   unsigned int jresult ;
11571   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11572   Dali::Quaternion *arg2 = 0 ;
11573   bool result;
11574
11575   arg1 = (Dali::Quaternion *)jarg1;
11576   arg2 = (Dali::Quaternion *)jarg2;
11577   if (!arg2) {
11578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11579     return 0;
11580   }
11581   {
11582     try {
11583       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11584     } catch (std::out_of_range& e) {
11585       {
11586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11587       };
11588     } catch (std::exception& e) {
11589       {
11590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11591       };
11592     } catch (Dali::DaliException e) {
11593       {
11594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11595       };
11596     } catch (...) {
11597       {
11598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11599       };
11600     }
11601   }
11602
11603   jresult = result;
11604   return jresult;
11605 }
11606
11607
11608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11609   unsigned int jresult ;
11610   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11611   Dali::Quaternion *arg2 = 0 ;
11612   bool result;
11613
11614   arg1 = (Dali::Quaternion *)jarg1;
11615   arg2 = (Dali::Quaternion *)jarg2;
11616   if (!arg2) {
11617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11618     return 0;
11619   }
11620   {
11621     try {
11622       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11623     } catch (std::out_of_range& e) {
11624       {
11625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11626       };
11627     } catch (std::exception& e) {
11628       {
11629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11630       };
11631     } catch (Dali::DaliException e) {
11632       {
11633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11634       };
11635     } catch (...) {
11636       {
11637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11638       };
11639     }
11640   }
11641
11642   jresult = result;
11643   return jresult;
11644 }
11645
11646
11647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11648   float jresult ;
11649   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11650   float result;
11651
11652   arg1 = (Dali::Quaternion *)jarg1;
11653   {
11654     try {
11655       result = (float)((Dali::Quaternion const *)arg1)->Length();
11656     } catch (std::out_of_range& e) {
11657       {
11658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11659       };
11660     } catch (std::exception& e) {
11661       {
11662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11663       };
11664     } catch (Dali::DaliException e) {
11665       {
11666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11667       };
11668     } catch (...) {
11669       {
11670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11671       };
11672     }
11673   }
11674
11675   jresult = result;
11676   return jresult;
11677 }
11678
11679
11680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11681   float jresult ;
11682   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11683   float result;
11684
11685   arg1 = (Dali::Quaternion *)jarg1;
11686   {
11687     try {
11688       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11689     } catch (std::out_of_range& e) {
11690       {
11691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11692       };
11693     } catch (std::exception& e) {
11694       {
11695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11696       };
11697     } catch (Dali::DaliException e) {
11698       {
11699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11700       };
11701     } catch (...) {
11702       {
11703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11704       };
11705     }
11706   }
11707
11708   jresult = result;
11709   return jresult;
11710 }
11711
11712
11713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11714   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11715
11716   arg1 = (Dali::Quaternion *)jarg1;
11717   {
11718     try {
11719       (arg1)->Normalize();
11720     } catch (std::out_of_range& e) {
11721       {
11722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11723       };
11724     } catch (std::exception& e) {
11725       {
11726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11727       };
11728     } catch (Dali::DaliException e) {
11729       {
11730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11731       };
11732     } catch (...) {
11733       {
11734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11735       };
11736     }
11737   }
11738
11739 }
11740
11741
11742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11743   void * jresult ;
11744   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11745   Dali::Quaternion result;
11746
11747   arg1 = (Dali::Quaternion *)jarg1;
11748   {
11749     try {
11750       result = ((Dali::Quaternion const *)arg1)->Normalized();
11751     } catch (std::out_of_range& e) {
11752       {
11753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11754       };
11755     } catch (std::exception& e) {
11756       {
11757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11758       };
11759     } catch (Dali::DaliException e) {
11760       {
11761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11762       };
11763     } catch (...) {
11764       {
11765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11766       };
11767     }
11768   }
11769
11770   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11771   return jresult;
11772 }
11773
11774
11775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11776   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11777
11778   arg1 = (Dali::Quaternion *)jarg1;
11779   {
11780     try {
11781       (arg1)->Conjugate();
11782     } catch (std::out_of_range& e) {
11783       {
11784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11785       };
11786     } catch (std::exception& e) {
11787       {
11788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11789       };
11790     } catch (Dali::DaliException e) {
11791       {
11792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11793       };
11794     } catch (...) {
11795       {
11796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11797       };
11798     }
11799   }
11800
11801 }
11802
11803
11804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11805   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11806
11807   arg1 = (Dali::Quaternion *)jarg1;
11808   {
11809     try {
11810       (arg1)->Invert();
11811     } catch (std::out_of_range& e) {
11812       {
11813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11814       };
11815     } catch (std::exception& e) {
11816       {
11817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11818       };
11819     } catch (Dali::DaliException e) {
11820       {
11821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11822       };
11823     } catch (...) {
11824       {
11825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11826       };
11827     }
11828   }
11829
11830 }
11831
11832
11833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11834   void * jresult ;
11835   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11836   Dali::Quaternion result;
11837
11838   arg1 = (Dali::Quaternion *)jarg1;
11839   {
11840     try {
11841       result = ((Dali::Quaternion const *)arg1)->Log();
11842     } catch (std::out_of_range& e) {
11843       {
11844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11845       };
11846     } catch (std::exception& e) {
11847       {
11848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11849       };
11850     } catch (Dali::DaliException e) {
11851       {
11852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11853       };
11854     } catch (...) {
11855       {
11856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11857       };
11858     }
11859   }
11860
11861   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11862   return jresult;
11863 }
11864
11865
11866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11867   void * jresult ;
11868   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11869   Dali::Quaternion result;
11870
11871   arg1 = (Dali::Quaternion *)jarg1;
11872   {
11873     try {
11874       result = ((Dali::Quaternion const *)arg1)->Exp();
11875     } catch (std::out_of_range& e) {
11876       {
11877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11878       };
11879     } catch (std::exception& e) {
11880       {
11881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11882       };
11883     } catch (Dali::DaliException e) {
11884       {
11885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11886       };
11887     } catch (...) {
11888       {
11889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11890       };
11891     }
11892   }
11893
11894   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11895   return jresult;
11896 }
11897
11898
11899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11900   float jresult ;
11901   Dali::Quaternion *arg1 = 0 ;
11902   Dali::Quaternion *arg2 = 0 ;
11903   float result;
11904
11905   arg1 = (Dali::Quaternion *)jarg1;
11906   if (!arg1) {
11907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11908     return 0;
11909   }
11910   arg2 = (Dali::Quaternion *)jarg2;
11911   if (!arg2) {
11912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11913     return 0;
11914   }
11915   {
11916     try {
11917       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11918     } catch (std::out_of_range& e) {
11919       {
11920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11921       };
11922     } catch (std::exception& e) {
11923       {
11924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11925       };
11926     } catch (Dali::DaliException e) {
11927       {
11928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11929       };
11930     } catch (...) {
11931       {
11932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11933       };
11934     }
11935   }
11936
11937   jresult = result;
11938   return jresult;
11939 }
11940
11941
11942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11943   void * jresult ;
11944   Dali::Quaternion *arg1 = 0 ;
11945   Dali::Quaternion *arg2 = 0 ;
11946   float arg3 ;
11947   Dali::Quaternion result;
11948
11949   arg1 = (Dali::Quaternion *)jarg1;
11950   if (!arg1) {
11951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11952     return 0;
11953   }
11954   arg2 = (Dali::Quaternion *)jarg2;
11955   if (!arg2) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11957     return 0;
11958   }
11959   arg3 = (float)jarg3;
11960   {
11961     try {
11962       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11963     } catch (std::out_of_range& e) {
11964       {
11965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11966       };
11967     } catch (std::exception& e) {
11968       {
11969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11970       };
11971     } catch (Dali::DaliException e) {
11972       {
11973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11974       };
11975     } catch (...) {
11976       {
11977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11978       };
11979     }
11980   }
11981
11982   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11983   return jresult;
11984 }
11985
11986
11987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11988   void * jresult ;
11989   Dali::Quaternion *arg1 = 0 ;
11990   Dali::Quaternion *arg2 = 0 ;
11991   float arg3 ;
11992   Dali::Quaternion result;
11993
11994   arg1 = (Dali::Quaternion *)jarg1;
11995   if (!arg1) {
11996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11997     return 0;
11998   }
11999   arg2 = (Dali::Quaternion *)jarg2;
12000   if (!arg2) {
12001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12002     return 0;
12003   }
12004   arg3 = (float)jarg3;
12005   {
12006     try {
12007       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12008     } catch (std::out_of_range& e) {
12009       {
12010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12011       };
12012     } catch (std::exception& e) {
12013       {
12014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12015       };
12016     } catch (Dali::DaliException e) {
12017       {
12018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12019       };
12020     } catch (...) {
12021       {
12022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12023       };
12024     }
12025   }
12026
12027   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12028   return jresult;
12029 }
12030
12031
12032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12033   void * jresult ;
12034   Dali::Quaternion *arg1 = 0 ;
12035   Dali::Quaternion *arg2 = 0 ;
12036   float arg3 ;
12037   Dali::Quaternion result;
12038
12039   arg1 = (Dali::Quaternion *)jarg1;
12040   if (!arg1) {
12041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12042     return 0;
12043   }
12044   arg2 = (Dali::Quaternion *)jarg2;
12045   if (!arg2) {
12046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12047     return 0;
12048   }
12049   arg3 = (float)jarg3;
12050   {
12051     try {
12052       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12053     } catch (std::out_of_range& e) {
12054       {
12055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12056       };
12057     } catch (std::exception& e) {
12058       {
12059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12060       };
12061     } catch (Dali::DaliException e) {
12062       {
12063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12064       };
12065     } catch (...) {
12066       {
12067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12068       };
12069     }
12070   }
12071
12072   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12073   return jresult;
12074 }
12075
12076
12077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12078   void * jresult ;
12079   Dali::Quaternion *arg1 = 0 ;
12080   Dali::Quaternion *arg2 = 0 ;
12081   Dali::Quaternion *arg3 = 0 ;
12082   Dali::Quaternion *arg4 = 0 ;
12083   float arg5 ;
12084   Dali::Quaternion result;
12085
12086   arg1 = (Dali::Quaternion *)jarg1;
12087   if (!arg1) {
12088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12089     return 0;
12090   }
12091   arg2 = (Dali::Quaternion *)jarg2;
12092   if (!arg2) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12094     return 0;
12095   }
12096   arg3 = (Dali::Quaternion *)jarg3;
12097   if (!arg3) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg4 = (Dali::Quaternion *)jarg4;
12102   if (!arg4) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   arg5 = (float)jarg5;
12107   {
12108     try {
12109       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12110     } catch (std::out_of_range& e) {
12111       {
12112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12113       };
12114     } catch (std::exception& e) {
12115       {
12116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12117       };
12118     } catch (Dali::DaliException e) {
12119       {
12120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12121       };
12122     } catch (...) {
12123       {
12124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12125       };
12126     }
12127   }
12128
12129   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12130   return jresult;
12131 }
12132
12133
12134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12135   float jresult ;
12136   Dali::Quaternion *arg1 = 0 ;
12137   Dali::Quaternion *arg2 = 0 ;
12138   float result;
12139
12140   arg1 = (Dali::Quaternion *)jarg1;
12141   if (!arg1) {
12142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12143     return 0;
12144   }
12145   arg2 = (Dali::Quaternion *)jarg2;
12146   if (!arg2) {
12147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12148     return 0;
12149   }
12150   {
12151     try {
12152       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12153     } catch (std::out_of_range& e) {
12154       {
12155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12156       };
12157     } catch (std::exception& e) {
12158       {
12159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12160       };
12161     } catch (Dali::DaliException e) {
12162       {
12163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12164       };
12165     } catch (...) {
12166       {
12167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12168       };
12169     }
12170   }
12171
12172   jresult = result;
12173   return jresult;
12174 }
12175
12176
12177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12178   void * jresult ;
12179   Dali::Matrix *result = 0 ;
12180
12181   {
12182     try {
12183       result = (Dali::Matrix *)new Dali::Matrix();
12184     } catch (std::out_of_range& e) {
12185       {
12186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12187       };
12188     } catch (std::exception& e) {
12189       {
12190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12191       };
12192     } catch (Dali::DaliException e) {
12193       {
12194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12195       };
12196     } catch (...) {
12197       {
12198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12199       };
12200     }
12201   }
12202
12203   jresult = (void *)result;
12204   return jresult;
12205 }
12206
12207
12208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12209   void * jresult ;
12210   bool arg1 ;
12211   Dali::Matrix *result = 0 ;
12212
12213   arg1 = jarg1 ? true : false;
12214   {
12215     try {
12216       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12217     } catch (std::out_of_range& e) {
12218       {
12219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12220       };
12221     } catch (std::exception& e) {
12222       {
12223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12224       };
12225     } catch (Dali::DaliException e) {
12226       {
12227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12228       };
12229     } catch (...) {
12230       {
12231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12232       };
12233     }
12234   }
12235
12236   jresult = (void *)result;
12237   return jresult;
12238 }
12239
12240
12241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12242   void * jresult ;
12243   float *arg1 = (float *) 0 ;
12244   Dali::Matrix *result = 0 ;
12245
12246   arg1 = jarg1;
12247   {
12248     try {
12249       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12250     } catch (std::out_of_range& e) {
12251       {
12252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12253       };
12254     } catch (std::exception& e) {
12255       {
12256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12257       };
12258     } catch (Dali::DaliException e) {
12259       {
12260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12261       };
12262     } catch (...) {
12263       {
12264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12265       };
12266     }
12267   }
12268
12269   jresult = (void *)result;
12270
12271
12272   return jresult;
12273 }
12274
12275
12276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12277   void * jresult ;
12278   Dali::Quaternion *arg1 = 0 ;
12279   Dali::Matrix *result = 0 ;
12280
12281   arg1 = (Dali::Quaternion *)jarg1;
12282   if (!arg1) {
12283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12284     return 0;
12285   }
12286   {
12287     try {
12288       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12289     } catch (std::out_of_range& e) {
12290       {
12291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12292       };
12293     } catch (std::exception& e) {
12294       {
12295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12296       };
12297     } catch (Dali::DaliException e) {
12298       {
12299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12300       };
12301     } catch (...) {
12302       {
12303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12304       };
12305     }
12306   }
12307
12308   jresult = (void *)result;
12309   return jresult;
12310 }
12311
12312
12313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12314   void * jresult ;
12315   Dali::Matrix *arg1 = 0 ;
12316   Dali::Matrix *result = 0 ;
12317
12318   arg1 = (Dali::Matrix *)jarg1;
12319   if (!arg1) {
12320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12321     return 0;
12322   }
12323   {
12324     try {
12325       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12326     } catch (std::out_of_range& e) {
12327       {
12328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12329       };
12330     } catch (std::exception& e) {
12331       {
12332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12333       };
12334     } catch (Dali::DaliException e) {
12335       {
12336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12337       };
12338     } catch (...) {
12339       {
12340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12341       };
12342     }
12343   }
12344
12345   jresult = (void *)result;
12346   return jresult;
12347 }
12348
12349
12350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12351   void * jresult ;
12352   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12353   Dali::Matrix *arg2 = 0 ;
12354   Dali::Matrix *result = 0 ;
12355
12356   arg1 = (Dali::Matrix *)jarg1;
12357   arg2 = (Dali::Matrix *)jarg2;
12358   if (!arg2) {
12359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12360     return 0;
12361   }
12362   {
12363     try {
12364       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12365     } catch (std::out_of_range& e) {
12366       {
12367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12368       };
12369     } catch (std::exception& e) {
12370       {
12371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12372       };
12373     } catch (Dali::DaliException e) {
12374       {
12375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12376       };
12377     } catch (...) {
12378       {
12379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12380       };
12381     }
12382   }
12383
12384   jresult = (void *)result;
12385   return jresult;
12386 }
12387
12388
12389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12390   void * jresult ;
12391   Dali::Matrix *result = 0 ;
12392
12393   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12394   jresult = (void *)result;
12395   return jresult;
12396 }
12397
12398
12399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12400   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12401
12402   arg1 = (Dali::Matrix *)jarg1;
12403   {
12404     try {
12405       (arg1)->SetIdentity();
12406     } catch (std::out_of_range& e) {
12407       {
12408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12409       };
12410     } catch (std::exception& e) {
12411       {
12412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12413       };
12414     } catch (Dali::DaliException e) {
12415       {
12416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12417       };
12418     } catch (...) {
12419       {
12420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12421       };
12422     }
12423   }
12424
12425 }
12426
12427
12428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12429   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12430   Dali::Vector3 *arg2 = 0 ;
12431
12432   arg1 = (Dali::Matrix *)jarg1;
12433   arg2 = (Dali::Vector3 *)jarg2;
12434   if (!arg2) {
12435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12436     return ;
12437   }
12438   {
12439     try {
12440       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12441     } catch (std::out_of_range& e) {
12442       {
12443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12444       };
12445     } catch (std::exception& e) {
12446       {
12447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12448       };
12449     } catch (Dali::DaliException e) {
12450       {
12451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12452       };
12453     } catch (...) {
12454       {
12455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12456       };
12457     }
12458   }
12459
12460 }
12461
12462
12463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12464   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12465   Dali::Matrix *arg2 = 0 ;
12466
12467   arg1 = (Dali::Matrix *)jarg1;
12468   arg2 = (Dali::Matrix *)jarg2;
12469   if (!arg2) {
12470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12471     return ;
12472   }
12473   {
12474     try {
12475       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12476     } catch (std::out_of_range& e) {
12477       {
12478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12479       };
12480     } catch (std::exception& e) {
12481       {
12482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12483       };
12484     } catch (Dali::DaliException e) {
12485       {
12486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12487       };
12488     } catch (...) {
12489       {
12490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12491       };
12492     }
12493   }
12494
12495 }
12496
12497
12498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12499   unsigned int jresult ;
12500   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12501   bool result;
12502
12503   arg1 = (Dali::Matrix *)jarg1;
12504   {
12505     try {
12506       result = (bool)(arg1)->Invert();
12507     } catch (std::out_of_range& e) {
12508       {
12509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12510       };
12511     } catch (std::exception& e) {
12512       {
12513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12514       };
12515     } catch (Dali::DaliException e) {
12516       {
12517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12518       };
12519     } catch (...) {
12520       {
12521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12522       };
12523     }
12524   }
12525
12526   jresult = result;
12527   return jresult;
12528 }
12529
12530
12531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12532   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12533
12534   arg1 = (Dali::Matrix *)jarg1;
12535   {
12536     try {
12537       (arg1)->Transpose();
12538     } catch (std::out_of_range& e) {
12539       {
12540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12541       };
12542     } catch (std::exception& e) {
12543       {
12544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12545       };
12546     } catch (Dali::DaliException e) {
12547       {
12548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12549       };
12550     } catch (...) {
12551       {
12552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12553       };
12554     }
12555   }
12556
12557 }
12558
12559
12560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12561   void * jresult ;
12562   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12563   Dali::Vector3 result;
12564
12565   arg1 = (Dali::Matrix *)jarg1;
12566   {
12567     try {
12568       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12569     } catch (std::out_of_range& e) {
12570       {
12571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12572       };
12573     } catch (std::exception& e) {
12574       {
12575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12576       };
12577     } catch (Dali::DaliException e) {
12578       {
12579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12580       };
12581     } catch (...) {
12582       {
12583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12584       };
12585     }
12586   }
12587
12588   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12589   return jresult;
12590 }
12591
12592
12593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12594   void * jresult ;
12595   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12596   Dali::Vector3 result;
12597
12598   arg1 = (Dali::Matrix *)jarg1;
12599   {
12600     try {
12601       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12602     } catch (std::out_of_range& e) {
12603       {
12604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12605       };
12606     } catch (std::exception& e) {
12607       {
12608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12609       };
12610     } catch (Dali::DaliException e) {
12611       {
12612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12613       };
12614     } catch (...) {
12615       {
12616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12617       };
12618     }
12619   }
12620
12621   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12622   return jresult;
12623 }
12624
12625
12626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12627   void * jresult ;
12628   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12629   Dali::Vector3 result;
12630
12631   arg1 = (Dali::Matrix *)jarg1;
12632   {
12633     try {
12634       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12635     } catch (std::out_of_range& e) {
12636       {
12637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12638       };
12639     } catch (std::exception& e) {
12640       {
12641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12642       };
12643     } catch (Dali::DaliException e) {
12644       {
12645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12646       };
12647     } catch (...) {
12648       {
12649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12650       };
12651     }
12652   }
12653
12654   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12655   return jresult;
12656 }
12657
12658
12659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12660   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12661   Dali::Vector3 *arg2 = 0 ;
12662
12663   arg1 = (Dali::Matrix *)jarg1;
12664   arg2 = (Dali::Vector3 *)jarg2;
12665   if (!arg2) {
12666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12667     return ;
12668   }
12669   {
12670     try {
12671       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12672     } catch (std::out_of_range& e) {
12673       {
12674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12675       };
12676     } catch (std::exception& e) {
12677       {
12678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12679       };
12680     } catch (Dali::DaliException e) {
12681       {
12682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12683       };
12684     } catch (...) {
12685       {
12686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12687       };
12688     }
12689   }
12690
12691 }
12692
12693
12694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12695   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12696   Dali::Vector3 *arg2 = 0 ;
12697
12698   arg1 = (Dali::Matrix *)jarg1;
12699   arg2 = (Dali::Vector3 *)jarg2;
12700   if (!arg2) {
12701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12702     return ;
12703   }
12704   {
12705     try {
12706       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12707     } catch (std::out_of_range& e) {
12708       {
12709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12710       };
12711     } catch (std::exception& e) {
12712       {
12713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12714       };
12715     } catch (Dali::DaliException e) {
12716       {
12717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12718       };
12719     } catch (...) {
12720       {
12721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12722       };
12723     }
12724   }
12725
12726 }
12727
12728
12729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12730   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12731   Dali::Vector3 *arg2 = 0 ;
12732
12733   arg1 = (Dali::Matrix *)jarg1;
12734   arg2 = (Dali::Vector3 *)jarg2;
12735   if (!arg2) {
12736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12737     return ;
12738   }
12739   {
12740     try {
12741       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12742     } catch (std::out_of_range& e) {
12743       {
12744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12745       };
12746     } catch (std::exception& e) {
12747       {
12748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12749       };
12750     } catch (Dali::DaliException e) {
12751       {
12752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12753       };
12754     } catch (...) {
12755       {
12756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12757       };
12758     }
12759   }
12760
12761 }
12762
12763
12764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12765   void * jresult ;
12766   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12767   Dali::Vector4 *result = 0 ;
12768
12769   arg1 = (Dali::Matrix *)jarg1;
12770   {
12771     try {
12772       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
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 (Dali::DaliException e) {
12782       {
12783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12784       };
12785     } catch (...) {
12786       {
12787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12788       };
12789     }
12790   }
12791
12792   jresult = (void *)result;
12793   return jresult;
12794 }
12795
12796
12797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12798   void * jresult ;
12799   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12800   Dali::Vector3 *result = 0 ;
12801
12802   arg1 = (Dali::Matrix *)jarg1;
12803   {
12804     try {
12805       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12806     } catch (std::out_of_range& e) {
12807       {
12808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12809       };
12810     } catch (std::exception& e) {
12811       {
12812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12813       };
12814     } catch (Dali::DaliException e) {
12815       {
12816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12817       };
12818     } catch (...) {
12819       {
12820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12821       };
12822     }
12823   }
12824
12825   jresult = (void *)result;
12826   return jresult;
12827 }
12828
12829
12830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12831   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12832   Dali::Vector4 *arg2 = 0 ;
12833
12834   arg1 = (Dali::Matrix *)jarg1;
12835   arg2 = (Dali::Vector4 *)jarg2;
12836   if (!arg2) {
12837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12838     return ;
12839   }
12840   {
12841     try {
12842       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12843     } catch (std::out_of_range& e) {
12844       {
12845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12846       };
12847     } catch (std::exception& e) {
12848       {
12849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12850       };
12851     } catch (Dali::DaliException e) {
12852       {
12853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12854       };
12855     } catch (...) {
12856       {
12857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12858       };
12859     }
12860   }
12861
12862 }
12863
12864
12865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12866   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12867   Dali::Vector3 *arg2 = 0 ;
12868
12869   arg1 = (Dali::Matrix *)jarg1;
12870   arg2 = (Dali::Vector3 *)jarg2;
12871   if (!arg2) {
12872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12873     return ;
12874   }
12875   {
12876     try {
12877       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12878     } catch (std::out_of_range& e) {
12879       {
12880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12881       };
12882     } catch (std::exception& e) {
12883       {
12884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12885       };
12886     } catch (Dali::DaliException e) {
12887       {
12888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12889       };
12890     } catch (...) {
12891       {
12892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12893       };
12894     }
12895   }
12896
12897 }
12898
12899
12900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12901   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12902
12903   arg1 = (Dali::Matrix *)jarg1;
12904   {
12905     try {
12906       (arg1)->OrthoNormalize();
12907     } catch (std::out_of_range& e) {
12908       {
12909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12910       };
12911     } catch (std::exception& e) {
12912       {
12913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12914       };
12915     } catch (Dali::DaliException e) {
12916       {
12917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12918       };
12919     } catch (...) {
12920       {
12921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12922       };
12923     }
12924   }
12925
12926 }
12927
12928
12929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12930   void * jresult ;
12931   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12932   float *result = 0 ;
12933
12934   arg1 = (Dali::Matrix *)jarg1;
12935   {
12936     try {
12937       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12938     } catch (std::out_of_range& e) {
12939       {
12940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12941       };
12942     } catch (std::exception& e) {
12943       {
12944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12945       };
12946     } catch (Dali::DaliException e) {
12947       {
12948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12949       };
12950     } catch (...) {
12951       {
12952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12953       };
12954     }
12955   }
12956
12957   jresult = (void *)result;
12958   return jresult;
12959 }
12960
12961
12962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12963   Dali::Matrix *arg1 = 0 ;
12964   Dali::Matrix *arg2 = 0 ;
12965   Dali::Matrix *arg3 = 0 ;
12966
12967   arg1 = (Dali::Matrix *)jarg1;
12968   if (!arg1) {
12969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12970     return ;
12971   }
12972   arg2 = (Dali::Matrix *)jarg2;
12973   if (!arg2) {
12974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12975     return ;
12976   }
12977   arg3 = (Dali::Matrix *)jarg3;
12978   if (!arg3) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12980     return ;
12981   }
12982   {
12983     try {
12984       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12985     } catch (std::out_of_range& e) {
12986       {
12987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12988       };
12989     } catch (std::exception& e) {
12990       {
12991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12992       };
12993     } catch (Dali::DaliException e) {
12994       {
12995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12996       };
12997     } catch (...) {
12998       {
12999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13000       };
13001     }
13002   }
13003
13004 }
13005
13006
13007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13008   Dali::Matrix *arg1 = 0 ;
13009   Dali::Matrix *arg2 = 0 ;
13010   Dali::Quaternion *arg3 = 0 ;
13011
13012   arg1 = (Dali::Matrix *)jarg1;
13013   if (!arg1) {
13014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13015     return ;
13016   }
13017   arg2 = (Dali::Matrix *)jarg2;
13018   if (!arg2) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13020     return ;
13021   }
13022   arg3 = (Dali::Quaternion *)jarg3;
13023   if (!arg3) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13025     return ;
13026   }
13027   {
13028     try {
13029       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13030     } catch (std::out_of_range& e) {
13031       {
13032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13033       };
13034     } catch (std::exception& e) {
13035       {
13036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13037       };
13038     } catch (Dali::DaliException e) {
13039       {
13040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13041       };
13042     } catch (...) {
13043       {
13044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13045       };
13046     }
13047   }
13048
13049 }
13050
13051
13052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13053   void * jresult ;
13054   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13055   Dali::Vector4 *arg2 = 0 ;
13056   Dali::Vector4 result;
13057
13058   arg1 = (Dali::Matrix *)jarg1;
13059   arg2 = (Dali::Vector4 *)jarg2;
13060   if (!arg2) {
13061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13062     return 0;
13063   }
13064   {
13065     try {
13066       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13067     } catch (std::out_of_range& e) {
13068       {
13069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13070       };
13071     } catch (std::exception& e) {
13072       {
13073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13074       };
13075     } catch (Dali::DaliException e) {
13076       {
13077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13078       };
13079     } catch (...) {
13080       {
13081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13082       };
13083     }
13084   }
13085
13086   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13087   return jresult;
13088 }
13089
13090
13091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13092   unsigned int jresult ;
13093   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13094   Dali::Matrix *arg2 = 0 ;
13095   bool result;
13096
13097   arg1 = (Dali::Matrix *)jarg1;
13098   arg2 = (Dali::Matrix *)jarg2;
13099   if (!arg2) {
13100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13101     return 0;
13102   }
13103   {
13104     try {
13105       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13106     } catch (std::out_of_range& e) {
13107       {
13108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13109       };
13110     } catch (std::exception& e) {
13111       {
13112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13113       };
13114     } catch (Dali::DaliException e) {
13115       {
13116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13117       };
13118     } catch (...) {
13119       {
13120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13121       };
13122     }
13123   }
13124
13125   jresult = result;
13126   return jresult;
13127 }
13128
13129
13130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13131   unsigned int jresult ;
13132   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13133   Dali::Matrix *arg2 = 0 ;
13134   bool result;
13135
13136   arg1 = (Dali::Matrix *)jarg1;
13137   arg2 = (Dali::Matrix *)jarg2;
13138   if (!arg2) {
13139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13140     return 0;
13141   }
13142   {
13143     try {
13144       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13145     } catch (std::out_of_range& e) {
13146       {
13147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13148       };
13149     } catch (std::exception& e) {
13150       {
13151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13152       };
13153     } catch (Dali::DaliException e) {
13154       {
13155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13156       };
13157     } catch (...) {
13158       {
13159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13160       };
13161     }
13162   }
13163
13164   jresult = result;
13165   return jresult;
13166 }
13167
13168
13169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13170   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13171   Dali::Vector3 *arg2 = 0 ;
13172   Dali::Quaternion *arg3 = 0 ;
13173   Dali::Vector3 *arg4 = 0 ;
13174
13175   arg1 = (Dali::Matrix *)jarg1;
13176   arg2 = (Dali::Vector3 *)jarg2;
13177   if (!arg2) {
13178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13179     return ;
13180   }
13181   arg3 = (Dali::Quaternion *)jarg3;
13182   if (!arg3) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13184     return ;
13185   }
13186   arg4 = (Dali::Vector3 *)jarg4;
13187   if (!arg4) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13189     return ;
13190   }
13191   {
13192     try {
13193       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13194     } catch (std::out_of_range& e) {
13195       {
13196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13197       };
13198     } catch (std::exception& e) {
13199       {
13200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13201       };
13202     } catch (Dali::DaliException e) {
13203       {
13204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13205       };
13206     } catch (...) {
13207       {
13208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13209       };
13210     }
13211   }
13212
13213 }
13214
13215
13216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13217   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13218   Dali::Vector3 *arg2 = 0 ;
13219   Dali::Quaternion *arg3 = 0 ;
13220   Dali::Vector3 *arg4 = 0 ;
13221
13222   arg1 = (Dali::Matrix *)jarg1;
13223   arg2 = (Dali::Vector3 *)jarg2;
13224   if (!arg2) {
13225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13226     return ;
13227   }
13228   arg3 = (Dali::Quaternion *)jarg3;
13229   if (!arg3) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13231     return ;
13232   }
13233   arg4 = (Dali::Vector3 *)jarg4;
13234   if (!arg4) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13236     return ;
13237   }
13238   {
13239     try {
13240       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13241     } catch (std::out_of_range& e) {
13242       {
13243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13244       };
13245     } catch (std::exception& e) {
13246       {
13247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13248       };
13249     } catch (Dali::DaliException e) {
13250       {
13251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13252       };
13253     } catch (...) {
13254       {
13255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13256       };
13257     }
13258   }
13259
13260 }
13261
13262
13263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13264   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13265   Dali::Vector3 *arg2 = 0 ;
13266   Dali::Vector3 *arg3 = 0 ;
13267   Dali::Vector3 *arg4 = 0 ;
13268   Dali::Vector3 *arg5 = 0 ;
13269
13270   arg1 = (Dali::Matrix *)jarg1;
13271   arg2 = (Dali::Vector3 *)jarg2;
13272   if (!arg2) {
13273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13274     return ;
13275   }
13276   arg3 = (Dali::Vector3 *)jarg3;
13277   if (!arg3) {
13278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13279     return ;
13280   }
13281   arg4 = (Dali::Vector3 *)jarg4;
13282   if (!arg4) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13284     return ;
13285   }
13286   arg5 = (Dali::Vector3 *)jarg5;
13287   if (!arg5) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13289     return ;
13290   }
13291   {
13292     try {
13293       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13294     } catch (std::out_of_range& e) {
13295       {
13296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13297       };
13298     } catch (std::exception& e) {
13299       {
13300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13301       };
13302     } catch (Dali::DaliException e) {
13303       {
13304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13305       };
13306     } catch (...) {
13307       {
13308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13309       };
13310     }
13311   }
13312
13313 }
13314
13315
13316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13317   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13318   Dali::Vector3 *arg2 = 0 ;
13319   Dali::Quaternion *arg3 = 0 ;
13320   Dali::Vector3 *arg4 = 0 ;
13321
13322   arg1 = (Dali::Matrix *)jarg1;
13323   arg2 = (Dali::Vector3 *)jarg2;
13324   if (!arg2) {
13325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13326     return ;
13327   }
13328   arg3 = (Dali::Quaternion *)jarg3;
13329   if (!arg3) {
13330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13331     return ;
13332   }
13333   arg4 = (Dali::Vector3 *)jarg4;
13334   if (!arg4) {
13335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13336     return ;
13337   }
13338   {
13339     try {
13340       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
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 (Dali::DaliException e) {
13350       {
13351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13352       };
13353     } catch (...) {
13354       {
13355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13356       };
13357     }
13358   }
13359
13360 }
13361
13362
13363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13364   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13365
13366   arg1 = (Dali::Matrix *)jarg1;
13367   {
13368     try {
13369       delete arg1;
13370     } catch (std::out_of_range& e) {
13371       {
13372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13373       };
13374     } catch (std::exception& e) {
13375       {
13376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13377       };
13378     } catch (Dali::DaliException e) {
13379       {
13380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13381       };
13382     } catch (...) {
13383       {
13384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13385       };
13386     }
13387   }
13388
13389 }
13390
13391
13392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13393   void * jresult ;
13394   Dali::Matrix3 *result = 0 ;
13395
13396   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13397   jresult = (void *)result;
13398   return jresult;
13399 }
13400
13401
13402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13403   void * jresult ;
13404   Dali::Matrix3 *result = 0 ;
13405
13406   {
13407     try {
13408       result = (Dali::Matrix3 *)new Dali::Matrix3();
13409     } catch (std::out_of_range& e) {
13410       {
13411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13412       };
13413     } catch (std::exception& e) {
13414       {
13415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13416       };
13417     } catch (Dali::DaliException e) {
13418       {
13419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13420       };
13421     } catch (...) {
13422       {
13423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13424       };
13425     }
13426   }
13427
13428   jresult = (void *)result;
13429   return jresult;
13430 }
13431
13432
13433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13434   void * jresult ;
13435   Dali::Matrix3 *arg1 = 0 ;
13436   Dali::Matrix3 *result = 0 ;
13437
13438   arg1 = (Dali::Matrix3 *)jarg1;
13439   if (!arg1) {
13440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13441     return 0;
13442   }
13443   {
13444     try {
13445       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13446     } catch (std::out_of_range& e) {
13447       {
13448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13449       };
13450     } catch (std::exception& e) {
13451       {
13452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13453       };
13454     } catch (Dali::DaliException e) {
13455       {
13456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13457       };
13458     } catch (...) {
13459       {
13460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13461       };
13462     }
13463   }
13464
13465   jresult = (void *)result;
13466   return jresult;
13467 }
13468
13469
13470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13471   void * jresult ;
13472   Dali::Matrix *arg1 = 0 ;
13473   Dali::Matrix3 *result = 0 ;
13474
13475   arg1 = (Dali::Matrix *)jarg1;
13476   if (!arg1) {
13477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13478     return 0;
13479   }
13480   {
13481     try {
13482       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
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 (Dali::DaliException e) {
13492       {
13493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13494       };
13495     } catch (...) {
13496       {
13497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13498       };
13499     }
13500   }
13501
13502   jresult = (void *)result;
13503   return jresult;
13504 }
13505
13506
13507 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) {
13508   void * jresult ;
13509   float arg1 ;
13510   float arg2 ;
13511   float arg3 ;
13512   float arg4 ;
13513   float arg5 ;
13514   float arg6 ;
13515   float arg7 ;
13516   float arg8 ;
13517   float arg9 ;
13518   Dali::Matrix3 *result = 0 ;
13519
13520   arg1 = (float)jarg1;
13521   arg2 = (float)jarg2;
13522   arg3 = (float)jarg3;
13523   arg4 = (float)jarg4;
13524   arg5 = (float)jarg5;
13525   arg6 = (float)jarg6;
13526   arg7 = (float)jarg7;
13527   arg8 = (float)jarg8;
13528   arg9 = (float)jarg9;
13529   {
13530     try {
13531       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13532     } catch (std::out_of_range& e) {
13533       {
13534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13535       };
13536     } catch (std::exception& e) {
13537       {
13538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13539       };
13540     } catch (Dali::DaliException e) {
13541       {
13542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13543       };
13544     } catch (...) {
13545       {
13546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13547       };
13548     }
13549   }
13550
13551   jresult = (void *)result;
13552   return jresult;
13553 }
13554
13555
13556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13557   void * jresult ;
13558   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13559   Dali::Matrix3 *arg2 = 0 ;
13560   Dali::Matrix3 *result = 0 ;
13561
13562   arg1 = (Dali::Matrix3 *)jarg1;
13563   arg2 = (Dali::Matrix3 *)jarg2;
13564   if (!arg2) {
13565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13566     return 0;
13567   }
13568   {
13569     try {
13570       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13571     } catch (std::out_of_range& e) {
13572       {
13573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13574       };
13575     } catch (std::exception& e) {
13576       {
13577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13578       };
13579     } catch (Dali::DaliException e) {
13580       {
13581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13582       };
13583     } catch (...) {
13584       {
13585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13586       };
13587     }
13588   }
13589
13590   jresult = (void *)result;
13591   return jresult;
13592 }
13593
13594
13595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13596   void * jresult ;
13597   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13598   Dali::Matrix *arg2 = 0 ;
13599   Dali::Matrix3 *result = 0 ;
13600
13601   arg1 = (Dali::Matrix3 *)jarg1;
13602   arg2 = (Dali::Matrix *)jarg2;
13603   if (!arg2) {
13604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13605     return 0;
13606   }
13607   {
13608     try {
13609       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13610     } catch (std::out_of_range& e) {
13611       {
13612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13613       };
13614     } catch (std::exception& e) {
13615       {
13616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13617       };
13618     } catch (Dali::DaliException e) {
13619       {
13620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13621       };
13622     } catch (...) {
13623       {
13624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13625       };
13626     }
13627   }
13628
13629   jresult = (void *)result;
13630   return jresult;
13631 }
13632
13633
13634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13635   unsigned int jresult ;
13636   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13637   Dali::Matrix3 *arg2 = 0 ;
13638   bool result;
13639
13640   arg1 = (Dali::Matrix3 *)jarg1;
13641   arg2 = (Dali::Matrix3 *)jarg2;
13642   if (!arg2) {
13643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13644     return 0;
13645   }
13646   {
13647     try {
13648       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13649     } catch (std::out_of_range& e) {
13650       {
13651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13652       };
13653     } catch (std::exception& e) {
13654       {
13655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13656       };
13657     } catch (Dali::DaliException e) {
13658       {
13659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13660       };
13661     } catch (...) {
13662       {
13663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13664       };
13665     }
13666   }
13667
13668   jresult = result;
13669   return jresult;
13670 }
13671
13672
13673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13674   unsigned int jresult ;
13675   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13676   Dali::Matrix3 *arg2 = 0 ;
13677   bool result;
13678
13679   arg1 = (Dali::Matrix3 *)jarg1;
13680   arg2 = (Dali::Matrix3 *)jarg2;
13681   if (!arg2) {
13682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13683     return 0;
13684   }
13685   {
13686     try {
13687       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13688     } catch (std::out_of_range& e) {
13689       {
13690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13691       };
13692     } catch (std::exception& e) {
13693       {
13694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13695       };
13696     } catch (Dali::DaliException e) {
13697       {
13698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13699       };
13700     } catch (...) {
13701       {
13702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13703       };
13704     }
13705   }
13706
13707   jresult = result;
13708   return jresult;
13709 }
13710
13711
13712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13713   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13714
13715   arg1 = (Dali::Matrix3 *)jarg1;
13716   {
13717     try {
13718       delete arg1;
13719     } catch (std::out_of_range& e) {
13720       {
13721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13722       };
13723     } catch (std::exception& e) {
13724       {
13725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13726       };
13727     } catch (Dali::DaliException e) {
13728       {
13729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13730       };
13731     } catch (...) {
13732       {
13733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13734       };
13735     }
13736   }
13737
13738 }
13739
13740
13741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13742   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13743
13744   arg1 = (Dali::Matrix3 *)jarg1;
13745   {
13746     try {
13747       (arg1)->SetIdentity();
13748     } catch (std::out_of_range& e) {
13749       {
13750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13751       };
13752     } catch (std::exception& e) {
13753       {
13754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13755       };
13756     } catch (Dali::DaliException e) {
13757       {
13758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13759       };
13760     } catch (...) {
13761       {
13762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13763       };
13764     }
13765   }
13766
13767 }
13768
13769
13770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13771   void * jresult ;
13772   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13773   float *result = 0 ;
13774
13775   arg1 = (Dali::Matrix3 *)jarg1;
13776   {
13777     try {
13778       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13779     } catch (std::out_of_range& e) {
13780       {
13781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13782       };
13783     } catch (std::exception& e) {
13784       {
13785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13786       };
13787     } catch (Dali::DaliException e) {
13788       {
13789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13790       };
13791     } catch (...) {
13792       {
13793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13794       };
13795     }
13796   }
13797
13798   jresult = (void *)result;
13799   return jresult;
13800 }
13801
13802
13803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13804   unsigned int jresult ;
13805   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13806   bool result;
13807
13808   arg1 = (Dali::Matrix3 *)jarg1;
13809   {
13810     try {
13811       result = (bool)(arg1)->Invert();
13812     } catch (std::out_of_range& e) {
13813       {
13814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13815       };
13816     } catch (std::exception& e) {
13817       {
13818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13819       };
13820     } catch (Dali::DaliException e) {
13821       {
13822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13823       };
13824     } catch (...) {
13825       {
13826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13827       };
13828     }
13829   }
13830
13831   jresult = result;
13832   return jresult;
13833 }
13834
13835
13836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13837   unsigned int jresult ;
13838   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13839   bool result;
13840
13841   arg1 = (Dali::Matrix3 *)jarg1;
13842   {
13843     try {
13844       result = (bool)(arg1)->Transpose();
13845     } catch (std::out_of_range& e) {
13846       {
13847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13848       };
13849     } catch (std::exception& e) {
13850       {
13851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13852       };
13853     } catch (Dali::DaliException e) {
13854       {
13855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13856       };
13857     } catch (...) {
13858       {
13859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13860       };
13861     }
13862   }
13863
13864   jresult = result;
13865   return jresult;
13866 }
13867
13868
13869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13870   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13871   float arg2 ;
13872
13873   arg1 = (Dali::Matrix3 *)jarg1;
13874   arg2 = (float)jarg2;
13875   {
13876     try {
13877       (arg1)->Scale(arg2);
13878     } catch (std::out_of_range& e) {
13879       {
13880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13881       };
13882     } catch (std::exception& e) {
13883       {
13884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13885       };
13886     } catch (Dali::DaliException e) {
13887       {
13888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13889       };
13890     } catch (...) {
13891       {
13892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13893       };
13894     }
13895   }
13896
13897 }
13898
13899
13900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13901   float jresult ;
13902   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13903   float result;
13904
13905   arg1 = (Dali::Matrix3 *)jarg1;
13906   {
13907     try {
13908       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13909     } catch (std::out_of_range& e) {
13910       {
13911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13912       };
13913     } catch (std::exception& e) {
13914       {
13915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13916       };
13917     } catch (Dali::DaliException e) {
13918       {
13919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13920       };
13921     } catch (...) {
13922       {
13923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13924       };
13925     }
13926   }
13927
13928   jresult = result;
13929   return jresult;
13930 }
13931
13932
13933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13934   unsigned int jresult ;
13935   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13936   bool result;
13937
13938   arg1 = (Dali::Matrix3 *)jarg1;
13939   {
13940     try {
13941       result = (bool)(arg1)->ScaledInverseTranspose();
13942     } catch (std::out_of_range& e) {
13943       {
13944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13945       };
13946     } catch (std::exception& e) {
13947       {
13948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13949       };
13950     } catch (Dali::DaliException e) {
13951       {
13952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13953       };
13954     } catch (...) {
13955       {
13956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13957       };
13958     }
13959   }
13960
13961   jresult = result;
13962   return jresult;
13963 }
13964
13965
13966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13967   Dali::Matrix3 *arg1 = 0 ;
13968   Dali::Matrix3 *arg2 = 0 ;
13969   Dali::Matrix3 *arg3 = 0 ;
13970
13971   arg1 = (Dali::Matrix3 *)jarg1;
13972   if (!arg1) {
13973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13974     return ;
13975   }
13976   arg2 = (Dali::Matrix3 *)jarg2;
13977   if (!arg2) {
13978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13979     return ;
13980   }
13981   arg3 = (Dali::Matrix3 *)jarg3;
13982   if (!arg3) {
13983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13984     return ;
13985   }
13986   {
13987     try {
13988       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13989     } catch (std::out_of_range& e) {
13990       {
13991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13992       };
13993     } catch (std::exception& e) {
13994       {
13995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13996       };
13997     } catch (Dali::DaliException e) {
13998       {
13999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14000       };
14001     } catch (...) {
14002       {
14003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14004       };
14005     }
14006   }
14007
14008 }
14009
14010
14011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14012   float jresult ;
14013   float arg1 ;
14014   float arg2 ;
14015   float result;
14016
14017   arg1 = (float)jarg1;
14018   arg2 = (float)jarg2;
14019   {
14020     try {
14021       result = (float)Dali::Random::Range(arg1,arg2);
14022     } catch (std::out_of_range& e) {
14023       {
14024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14025       };
14026     } catch (std::exception& e) {
14027       {
14028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14029       };
14030     } catch (Dali::DaliException e) {
14031       {
14032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14033       };
14034     } catch (...) {
14035       {
14036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14037       };
14038     }
14039   }
14040
14041   jresult = result;
14042   return jresult;
14043 }
14044
14045
14046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14047   void * jresult ;
14048   Dali::Vector4 result;
14049
14050   {
14051     try {
14052       result = Dali::Random::Axis();
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 (Dali::DaliException e) {
14062       {
14063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14064       };
14065     } catch (...) {
14066       {
14067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14068       };
14069     }
14070   }
14071
14072   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14073   return jresult;
14074 }
14075
14076
14077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14078   void * jresult ;
14079   Dali::AngleAxis *result = 0 ;
14080
14081   {
14082     try {
14083       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14084     } catch (std::out_of_range& e) {
14085       {
14086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14087       };
14088     } catch (std::exception& e) {
14089       {
14090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14091       };
14092     } catch (Dali::DaliException e) {
14093       {
14094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14095       };
14096     } catch (...) {
14097       {
14098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14099       };
14100     }
14101   }
14102
14103   jresult = (void *)result;
14104   return jresult;
14105 }
14106
14107
14108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14109   void * jresult ;
14110   Dali::Radian arg1 ;
14111   Dali::Vector3 *arg2 = 0 ;
14112   Dali::Radian *argp1 ;
14113   Dali::AngleAxis *result = 0 ;
14114
14115   argp1 = (Dali::Radian *)jarg1;
14116   if (!argp1) {
14117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14118     return 0;
14119   }
14120   arg1 = *argp1;
14121   arg2 = (Dali::Vector3 *)jarg2;
14122   if (!arg2) {
14123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14124     return 0;
14125   }
14126   {
14127     try {
14128       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14129     } catch (std::out_of_range& e) {
14130       {
14131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14132       };
14133     } catch (std::exception& e) {
14134       {
14135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14136       };
14137     } catch (Dali::DaliException e) {
14138       {
14139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14140       };
14141     } catch (...) {
14142       {
14143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14144       };
14145     }
14146   }
14147
14148   jresult = (void *)result;
14149   return jresult;
14150 }
14151
14152
14153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14154   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14155   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14156
14157   arg1 = (Dali::AngleAxis *)jarg1;
14158   arg2 = (Dali::Radian *)jarg2;
14159   if (arg1) (arg1)->angle = *arg2;
14160 }
14161
14162
14163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14164   void * jresult ;
14165   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14166   Dali::Radian *result = 0 ;
14167
14168   arg1 = (Dali::AngleAxis *)jarg1;
14169   result = (Dali::Radian *)& ((arg1)->angle);
14170   jresult = (void *)result;
14171   return jresult;
14172 }
14173
14174
14175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14176   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14177   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14178
14179   arg1 = (Dali::AngleAxis *)jarg1;
14180   arg2 = (Dali::Vector3 *)jarg2;
14181   if (arg1) (arg1)->axis = *arg2;
14182 }
14183
14184
14185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14186   void * jresult ;
14187   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14188   Dali::Vector3 *result = 0 ;
14189
14190   arg1 = (Dali::AngleAxis *)jarg1;
14191   result = (Dali::Vector3 *)& ((arg1)->axis);
14192   jresult = (void *)result;
14193   return jresult;
14194 }
14195
14196
14197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14198   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14199
14200   arg1 = (Dali::AngleAxis *)jarg1;
14201   {
14202     try {
14203       delete arg1;
14204     } catch (std::out_of_range& e) {
14205       {
14206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14207       };
14208     } catch (std::exception& e) {
14209       {
14210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14211       };
14212     } catch (Dali::DaliException e) {
14213       {
14214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14215       };
14216     } catch (...) {
14217       {
14218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14219       };
14220     }
14221   }
14222
14223 }
14224
14225
14226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14227   unsigned int jresult ;
14228   Dali::AngleAxis *arg1 = 0 ;
14229   Dali::AngleAxis *arg2 = 0 ;
14230   bool result;
14231
14232   arg1 = (Dali::AngleAxis *)jarg1;
14233   if (!arg1) {
14234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14235     return 0;
14236   }
14237   arg2 = (Dali::AngleAxis *)jarg2;
14238   if (!arg2) {
14239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14240     return 0;
14241   }
14242   {
14243     try {
14244       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14245     } catch (std::out_of_range& e) {
14246       {
14247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14248       };
14249     } catch (std::exception& e) {
14250       {
14251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14252       };
14253     } catch (Dali::DaliException e) {
14254       {
14255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14256       };
14257     } catch (...) {
14258       {
14259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14260       };
14261     }
14262   }
14263
14264   jresult = result;
14265   return jresult;
14266 }
14267
14268
14269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14270   unsigned int jresult ;
14271   unsigned int arg1 ;
14272   unsigned int result;
14273
14274   arg1 = (unsigned int)jarg1;
14275   {
14276     try {
14277       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14278     } catch (std::out_of_range& e) {
14279       {
14280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14281       };
14282     } catch (std::exception& e) {
14283       {
14284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14285       };
14286     } catch (Dali::DaliException e) {
14287       {
14288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14289       };
14290     } catch (...) {
14291       {
14292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14293       };
14294     }
14295   }
14296
14297   jresult = result;
14298   return jresult;
14299 }
14300
14301
14302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14303   unsigned int jresult ;
14304   unsigned int arg1 ;
14305   bool result;
14306
14307   arg1 = (unsigned int)jarg1;
14308   {
14309     try {
14310       result = (bool)Dali::IsPowerOfTwo(arg1);
14311     } catch (std::out_of_range& e) {
14312       {
14313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14314       };
14315     } catch (std::exception& e) {
14316       {
14317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14318       };
14319     } catch (Dali::DaliException e) {
14320       {
14321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14322       };
14323     } catch (...) {
14324       {
14325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14326       };
14327     }
14328   }
14329
14330   jresult = result;
14331   return jresult;
14332 }
14333
14334
14335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14336   float jresult ;
14337   float arg1 ;
14338   float arg2 ;
14339   float result;
14340
14341   arg1 = (float)jarg1;
14342   arg2 = (float)jarg2;
14343   {
14344     try {
14345       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14346     } catch (std::out_of_range& e) {
14347       {
14348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14349       };
14350     } catch (std::exception& e) {
14351       {
14352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14353       };
14354     } catch (Dali::DaliException e) {
14355       {
14356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14357       };
14358     } catch (...) {
14359       {
14360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14361       };
14362     }
14363   }
14364
14365   jresult = result;
14366   return jresult;
14367 }
14368
14369
14370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14371   unsigned int jresult ;
14372   float arg1 ;
14373   bool result;
14374
14375   arg1 = (float)jarg1;
14376   {
14377     try {
14378       result = (bool)Dali::EqualsZero(arg1);
14379     } catch (std::out_of_range& e) {
14380       {
14381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14382       };
14383     } catch (std::exception& e) {
14384       {
14385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14386       };
14387     } catch (Dali::DaliException e) {
14388       {
14389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14390       };
14391     } catch (...) {
14392       {
14393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14394       };
14395     }
14396   }
14397
14398   jresult = result;
14399   return jresult;
14400 }
14401
14402
14403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14404   unsigned int jresult ;
14405   float arg1 ;
14406   float arg2 ;
14407   bool result;
14408
14409   arg1 = (float)jarg1;
14410   arg2 = (float)jarg2;
14411   {
14412     try {
14413       result = (bool)Dali::Equals(arg1,arg2);
14414     } catch (std::out_of_range& e) {
14415       {
14416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14417       };
14418     } catch (std::exception& e) {
14419       {
14420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14421       };
14422     } catch (Dali::DaliException e) {
14423       {
14424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14425       };
14426     } catch (...) {
14427       {
14428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14429       };
14430     }
14431   }
14432
14433   jresult = result;
14434   return jresult;
14435 }
14436
14437
14438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14439   unsigned int jresult ;
14440   float arg1 ;
14441   float arg2 ;
14442   float arg3 ;
14443   bool result;
14444
14445   arg1 = (float)jarg1;
14446   arg2 = (float)jarg2;
14447   arg3 = (float)jarg3;
14448   {
14449     try {
14450       result = (bool)Dali::Equals(arg1,arg2,arg3);
14451     } catch (std::out_of_range& e) {
14452       {
14453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14454       };
14455     } catch (std::exception& e) {
14456       {
14457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14458       };
14459     } catch (Dali::DaliException e) {
14460       {
14461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14462       };
14463     } catch (...) {
14464       {
14465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14466       };
14467     }
14468   }
14469
14470   jresult = result;
14471   return jresult;
14472 }
14473
14474
14475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14476   float jresult ;
14477   float arg1 ;
14478   int arg2 ;
14479   float result;
14480
14481   arg1 = (float)jarg1;
14482   arg2 = (int)jarg2;
14483   {
14484     try {
14485       result = (float)Dali::Round(arg1,arg2);
14486     } catch (std::out_of_range& e) {
14487       {
14488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14489       };
14490     } catch (std::exception& e) {
14491       {
14492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14493       };
14494     } catch (Dali::DaliException e) {
14495       {
14496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14497       };
14498     } catch (...) {
14499       {
14500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14501       };
14502     }
14503   }
14504
14505   jresult = result;
14506   return jresult;
14507 }
14508
14509
14510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14511   float jresult ;
14512   float arg1 ;
14513   float arg2 ;
14514   float arg3 ;
14515   float result;
14516
14517   arg1 = (float)jarg1;
14518   arg2 = (float)jarg2;
14519   arg3 = (float)jarg3;
14520   {
14521     try {
14522       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14523     } catch (std::out_of_range& e) {
14524       {
14525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14526       };
14527     } catch (std::exception& e) {
14528       {
14529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14530       };
14531     } catch (Dali::DaliException e) {
14532       {
14533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14534       };
14535     } catch (...) {
14536       {
14537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14538       };
14539     }
14540   }
14541
14542   jresult = result;
14543   return jresult;
14544 }
14545
14546
14547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14548   float jresult ;
14549   float arg1 ;
14550   float arg2 ;
14551   float arg3 ;
14552   float arg4 ;
14553   float result;
14554
14555   arg1 = (float)jarg1;
14556   arg2 = (float)jarg2;
14557   arg3 = (float)jarg3;
14558   arg4 = (float)jarg4;
14559   {
14560     try {
14561       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14562     } catch (std::out_of_range& e) {
14563       {
14564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14565       };
14566     } catch (std::exception& e) {
14567       {
14568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14569       };
14570     } catch (Dali::DaliException e) {
14571       {
14572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14573       };
14574     } catch (...) {
14575       {
14576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14577       };
14578     }
14579   }
14580
14581   jresult = result;
14582   return jresult;
14583 }
14584
14585
14586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14587   int jresult ;
14588   int result;
14589
14590   result = (int)(int)Dali::Property::INVALID_INDEX;
14591   jresult = result;
14592   return jresult;
14593 }
14594
14595
14596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14597   int jresult ;
14598   int result;
14599
14600   result = (int)(int)Dali::Property::INVALID_KEY;
14601   jresult = result;
14602   return jresult;
14603 }
14604
14605
14606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14607   int jresult ;
14608   int result;
14609
14610   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14611   jresult = result;
14612   return jresult;
14613 }
14614
14615
14616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14617   void * jresult ;
14618   Dali::Handle *arg1 = 0 ;
14619   Dali::Property::Index arg2 ;
14620   Dali::Property *result = 0 ;
14621
14622   arg1 = (Dali::Handle *)jarg1;
14623   if (!arg1) {
14624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14625     return 0;
14626   }
14627   arg2 = (Dali::Property::Index)jarg2;
14628   {
14629     try {
14630       result = (Dali::Property *)new Dali::Property(*arg1,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 (Dali::DaliException e) {
14640       {
14641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14642       };
14643     } catch (...) {
14644       {
14645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14646       };
14647     }
14648   }
14649
14650   jresult = (void *)result;
14651   return jresult;
14652 }
14653
14654
14655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14656   void * jresult ;
14657   Dali::Handle *arg1 = 0 ;
14658   Dali::Property::Index arg2 ;
14659   int arg3 ;
14660   Dali::Property *result = 0 ;
14661
14662   arg1 = (Dali::Handle *)jarg1;
14663   if (!arg1) {
14664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14665     return 0;
14666   }
14667   arg2 = (Dali::Property::Index)jarg2;
14668   arg3 = (int)jarg3;
14669   {
14670     try {
14671       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14672     } catch (std::out_of_range& e) {
14673       {
14674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14675       };
14676     } catch (std::exception& e) {
14677       {
14678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14679       };
14680     } catch (Dali::DaliException e) {
14681       {
14682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14683       };
14684     } catch (...) {
14685       {
14686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14687       };
14688     }
14689   }
14690
14691   jresult = (void *)result;
14692   return jresult;
14693 }
14694
14695
14696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14697   void * jresult ;
14698   Dali::Handle *arg1 = 0 ;
14699   std::string *arg2 = 0 ;
14700   Dali::Property *result = 0 ;
14701
14702   arg1 = (Dali::Handle *)jarg1;
14703   if (!arg1) {
14704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14705     return 0;
14706   }
14707   if (!jarg2) {
14708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14709     return 0;
14710   }
14711   std::string arg2_str(jarg2);
14712   arg2 = &arg2_str;
14713   {
14714     try {
14715       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14716     } catch (std::out_of_range& e) {
14717       {
14718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14719       };
14720     } catch (std::exception& e) {
14721       {
14722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14723       };
14724     } catch (Dali::DaliException e) {
14725       {
14726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14727       };
14728     } catch (...) {
14729       {
14730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14731       };
14732     }
14733   }
14734
14735   jresult = (void *)result;
14736
14737   //argout typemap for const std::string&
14738
14739   return jresult;
14740 }
14741
14742
14743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14744   void * jresult ;
14745   Dali::Handle *arg1 = 0 ;
14746   std::string *arg2 = 0 ;
14747   int arg3 ;
14748   Dali::Property *result = 0 ;
14749
14750   arg1 = (Dali::Handle *)jarg1;
14751   if (!arg1) {
14752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14753     return 0;
14754   }
14755   if (!jarg2) {
14756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14757     return 0;
14758   }
14759   std::string arg2_str(jarg2);
14760   arg2 = &arg2_str;
14761   arg3 = (int)jarg3;
14762   {
14763     try {
14764       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14765     } catch (std::out_of_range& e) {
14766       {
14767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14768       };
14769     } catch (std::exception& e) {
14770       {
14771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14772       };
14773     } catch (Dali::DaliException e) {
14774       {
14775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14776       };
14777     } catch (...) {
14778       {
14779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14780       };
14781     }
14782   }
14783
14784   jresult = (void *)result;
14785
14786   //argout typemap for const std::string&
14787
14788   return jresult;
14789 }
14790
14791
14792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14793   Dali::Property *arg1 = (Dali::Property *) 0 ;
14794
14795   arg1 = (Dali::Property *)jarg1;
14796   {
14797     try {
14798       delete arg1;
14799     } catch (std::out_of_range& e) {
14800       {
14801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14802       };
14803     } catch (std::exception& e) {
14804       {
14805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14806       };
14807     } catch (Dali::DaliException e) {
14808       {
14809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14810       };
14811     } catch (...) {
14812       {
14813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14814       };
14815     }
14816   }
14817
14818 }
14819
14820
14821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14822   Dali::Property *arg1 = (Dali::Property *) 0 ;
14823   Dali::Handle *arg2 = 0 ;
14824
14825   arg1 = (Dali::Property *)jarg1;
14826   arg2 = (Dali::Handle *)jarg2;
14827   if (!arg2) {
14828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14829     return ;
14830   }
14831   if (arg1) (arg1)->object = *arg2;
14832 }
14833
14834
14835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14836   void * jresult ;
14837   Dali::Property *arg1 = (Dali::Property *) 0 ;
14838   Dali::Handle *result = 0 ;
14839
14840   arg1 = (Dali::Property *)jarg1;
14841   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14842   jresult = (void *)result;
14843   return jresult;
14844 }
14845
14846
14847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14848   Dali::Property *arg1 = (Dali::Property *) 0 ;
14849   Dali::Property::Index arg2 ;
14850
14851   arg1 = (Dali::Property *)jarg1;
14852   arg2 = (Dali::Property::Index)jarg2;
14853   if (arg1) (arg1)->propertyIndex = arg2;
14854 }
14855
14856
14857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14858   int jresult ;
14859   Dali::Property *arg1 = (Dali::Property *) 0 ;
14860   Dali::Property::Index result;
14861
14862   arg1 = (Dali::Property *)jarg1;
14863   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14864   jresult = result;
14865   return jresult;
14866 }
14867
14868
14869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14870   Dali::Property *arg1 = (Dali::Property *) 0 ;
14871   int arg2 ;
14872
14873   arg1 = (Dali::Property *)jarg1;
14874   arg2 = (int)jarg2;
14875   if (arg1) (arg1)->componentIndex = arg2;
14876 }
14877
14878
14879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14880   int jresult ;
14881   Dali::Property *arg1 = (Dali::Property *) 0 ;
14882   int result;
14883
14884   arg1 = (Dali::Property *)jarg1;
14885   result = (int) ((arg1)->componentIndex);
14886   jresult = result;
14887   return jresult;
14888 }
14889
14890
14891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14892   void * jresult ;
14893   Dali::Property::Array *result = 0 ;
14894
14895   {
14896     try {
14897       result = (Dali::Property::Array *)new Dali::Property::Array();
14898     } catch (std::out_of_range& e) {
14899       {
14900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14901       };
14902     } catch (std::exception& e) {
14903       {
14904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14905       };
14906     } catch (Dali::DaliException e) {
14907       {
14908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14909       };
14910     } catch (...) {
14911       {
14912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14913       };
14914     }
14915   }
14916
14917   jresult = (void *)result;
14918   return jresult;
14919 }
14920
14921
14922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14923   void * jresult ;
14924   Dali::Property::Array *arg1 = 0 ;
14925   Dali::Property::Array *result = 0 ;
14926
14927   arg1 = (Dali::Property::Array *)jarg1;
14928   if (!arg1) {
14929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14930     return 0;
14931   }
14932   {
14933     try {
14934       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array 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 (Dali::DaliException e) {
14944       {
14945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14946       };
14947     } catch (...) {
14948       {
14949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14950       };
14951     }
14952   }
14953
14954   jresult = (void *)result;
14955   return jresult;
14956 }
14957
14958
14959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14960   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14961
14962   arg1 = (Dali::Property::Array *)jarg1;
14963   {
14964     try {
14965       delete arg1;
14966     } catch (std::out_of_range& e) {
14967       {
14968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14969       };
14970     } catch (std::exception& e) {
14971       {
14972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14973       };
14974     } catch (Dali::DaliException e) {
14975       {
14976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14977       };
14978     } catch (...) {
14979       {
14980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14981       };
14982     }
14983   }
14984
14985 }
14986
14987
14988 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14989   unsigned long jresult ;
14990   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14991   Dali::Property::Array::SizeType result;
14992
14993   arg1 = (Dali::Property::Array *)jarg1;
14994   {
14995     try {
14996       result = ((Dali::Property::Array const *)arg1)->Size();
14997     } catch (std::out_of_range& e) {
14998       {
14999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15000       };
15001     } catch (std::exception& e) {
15002       {
15003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15004       };
15005     } catch (Dali::DaliException e) {
15006       {
15007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15008       };
15009     } catch (...) {
15010       {
15011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15012       };
15013     }
15014   }
15015
15016   jresult = (unsigned long)result;
15017   return jresult;
15018 }
15019
15020
15021 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15022   unsigned long jresult ;
15023   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15024   Dali::Property::Array::SizeType result;
15025
15026   arg1 = (Dali::Property::Array *)jarg1;
15027   {
15028     try {
15029       result = ((Dali::Property::Array const *)arg1)->Count();
15030     } catch (std::out_of_range& e) {
15031       {
15032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15033       };
15034     } catch (std::exception& e) {
15035       {
15036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15037       };
15038     } catch (Dali::DaliException e) {
15039       {
15040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15041       };
15042     } catch (...) {
15043       {
15044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15045       };
15046     }
15047   }
15048
15049   jresult = (unsigned long)result;
15050   return jresult;
15051 }
15052
15053
15054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15055   unsigned int jresult ;
15056   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15057   bool result;
15058
15059   arg1 = (Dali::Property::Array *)jarg1;
15060   {
15061     try {
15062       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15063     } catch (std::out_of_range& e) {
15064       {
15065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15066       };
15067     } catch (std::exception& e) {
15068       {
15069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15070       };
15071     } catch (Dali::DaliException e) {
15072       {
15073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15074       };
15075     } catch (...) {
15076       {
15077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15078       };
15079     }
15080   }
15081
15082   jresult = result;
15083   return jresult;
15084 }
15085
15086
15087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15088   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15089
15090   arg1 = (Dali::Property::Array *)jarg1;
15091   {
15092     try {
15093       (arg1)->Clear();
15094     } catch (std::out_of_range& e) {
15095       {
15096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15097       };
15098     } catch (std::exception& e) {
15099       {
15100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15101       };
15102     } catch (Dali::DaliException e) {
15103       {
15104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15105       };
15106     } catch (...) {
15107       {
15108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15109       };
15110     }
15111   }
15112
15113 }
15114
15115
15116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15117   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15118   Dali::Property::Array::SizeType arg2 ;
15119
15120   arg1 = (Dali::Property::Array *)jarg1;
15121   arg2 = (Dali::Property::Array::SizeType)jarg2;
15122   {
15123     try {
15124       (arg1)->Reserve(arg2);
15125     } catch (std::out_of_range& e) {
15126       {
15127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15128       };
15129     } catch (std::exception& e) {
15130       {
15131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15132       };
15133     } catch (Dali::DaliException e) {
15134       {
15135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15136       };
15137     } catch (...) {
15138       {
15139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15140       };
15141     }
15142   }
15143
15144 }
15145
15146
15147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15148   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15149   Dali::Property::Array::SizeType arg2 ;
15150
15151   arg1 = (Dali::Property::Array *)jarg1;
15152   arg2 = (Dali::Property::Array::SizeType)jarg2;
15153   {
15154     try {
15155       (arg1)->Resize(arg2);
15156     } catch (std::out_of_range& e) {
15157       {
15158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15159       };
15160     } catch (std::exception& e) {
15161       {
15162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15163       };
15164     } catch (Dali::DaliException e) {
15165       {
15166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15167       };
15168     } catch (...) {
15169       {
15170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15171       };
15172     }
15173   }
15174
15175 }
15176
15177
15178 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15179   unsigned long jresult ;
15180   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15181   Dali::Property::Array::SizeType result;
15182
15183   arg1 = (Dali::Property::Array *)jarg1;
15184   {
15185     try {
15186       result = (arg1)->Capacity();
15187     } catch (std::out_of_range& e) {
15188       {
15189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15190       };
15191     } catch (std::exception& e) {
15192       {
15193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15194       };
15195     } catch (Dali::DaliException e) {
15196       {
15197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15198       };
15199     } catch (...) {
15200       {
15201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15202       };
15203     }
15204   }
15205
15206   jresult = (unsigned long)result;
15207   return jresult;
15208 }
15209
15210
15211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15212   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15213   Dali::Property::Value *arg2 = 0 ;
15214
15215   arg1 = (Dali::Property::Array *)jarg1;
15216   arg2 = (Dali::Property::Value *)jarg2;
15217   if (!arg2) {
15218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15219     return ;
15220   }
15221   {
15222     try {
15223       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15224     } catch (std::out_of_range& e) {
15225       {
15226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15227       };
15228     } catch (std::exception& e) {
15229       {
15230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15231       };
15232     } catch (Dali::DaliException e) {
15233       {
15234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15235       };
15236     } catch (...) {
15237       {
15238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15239       };
15240     }
15241   }
15242
15243 }
15244
15245
15246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15247   void * jresult ;
15248   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15249   Dali::Property::Value *arg2 = 0 ;
15250   Dali::Property::Array *result = 0 ;
15251
15252   arg1 = (Dali::Property::Array *)jarg1;
15253   arg2 = (Dali::Property::Value *)jarg2;
15254   if (!arg2) {
15255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15256     return 0;
15257   }
15258   {
15259     try {
15260       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15261     } catch (std::out_of_range& e) {
15262       {
15263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15264       };
15265     } catch (std::exception& e) {
15266       {
15267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15268       };
15269     } catch (Dali::DaliException e) {
15270       {
15271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15272       };
15273     } catch (...) {
15274       {
15275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15276       };
15277     }
15278   }
15279
15280   jresult = (void *)result;
15281   return jresult;
15282 }
15283
15284
15285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15286   void * jresult ;
15287   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15288   Dali::Property::Array::SizeType arg2 ;
15289   Dali::Property::Value *result = 0 ;
15290
15291   arg1 = (Dali::Property::Array *)jarg1;
15292   arg2 = (Dali::Property::Array::SizeType)jarg2;
15293   {
15294     try {
15295       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15296     } catch (std::out_of_range& e) {
15297       {
15298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15299       };
15300     } catch (std::exception& e) {
15301       {
15302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15303       };
15304     } catch (Dali::DaliException e) {
15305       {
15306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15307       };
15308     } catch (...) {
15309       {
15310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15311       };
15312     }
15313   }
15314
15315   jresult = (void *)result;
15316   return jresult;
15317 }
15318
15319
15320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15321   void * jresult ;
15322   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15323   Dali::Property::Array::SizeType arg2 ;
15324   Dali::Property::Value *result = 0 ;
15325
15326   arg1 = (Dali::Property::Array *)jarg1;
15327   arg2 = (Dali::Property::Array::SizeType)jarg2;
15328   {
15329     try {
15330       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15331     } catch (std::out_of_range& e) {
15332       {
15333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15334       };
15335     } catch (std::exception& e) {
15336       {
15337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15338       };
15339     } catch (Dali::DaliException e) {
15340       {
15341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15342       };
15343     } catch (...) {
15344       {
15345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15346       };
15347     }
15348   }
15349
15350   jresult = (void *)result;
15351   return jresult;
15352 }
15353
15354
15355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15356   void * jresult ;
15357   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15358   Dali::Property::Array *arg2 = 0 ;
15359   Dali::Property::Array *result = 0 ;
15360
15361   arg1 = (Dali::Property::Array *)jarg1;
15362   arg2 = (Dali::Property::Array *)jarg2;
15363   if (!arg2) {
15364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15365     return 0;
15366   }
15367   {
15368     try {
15369       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15370     } catch (std::out_of_range& e) {
15371       {
15372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15373       };
15374     } catch (std::exception& e) {
15375       {
15376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15377       };
15378     } catch (Dali::DaliException e) {
15379       {
15380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15381       };
15382     } catch (...) {
15383       {
15384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15385       };
15386     }
15387   }
15388
15389   jresult = (void *)result;
15390   return jresult;
15391 }
15392
15393
15394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15395   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15396   enum Dali::Property::Key::Type arg2 ;
15397
15398   arg1 = (Dali::Property::Key *)jarg1;
15399   arg2 = (enum Dali::Property::Key::Type)jarg2;
15400   if (arg1) (arg1)->type = arg2;
15401 }
15402
15403
15404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15405   int jresult ;
15406   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15407   enum Dali::Property::Key::Type result;
15408
15409   arg1 = (Dali::Property::Key *)jarg1;
15410   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15411   jresult = (int)result;
15412   return jresult;
15413 }
15414
15415
15416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15417   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15418   Dali::Property::Index arg2 ;
15419
15420   arg1 = (Dali::Property::Key *)jarg1;
15421   arg2 = (Dali::Property::Index)jarg2;
15422   if (arg1) (arg1)->indexKey = arg2;
15423 }
15424
15425
15426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15427   int jresult ;
15428   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15429   Dali::Property::Index result;
15430
15431   arg1 = (Dali::Property::Key *)jarg1;
15432   result = (Dali::Property::Index) ((arg1)->indexKey);
15433   jresult = result;
15434   return jresult;
15435 }
15436
15437
15438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15439   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15440   std::string *arg2 = 0 ;
15441
15442   arg1 = (Dali::Property::Key *)jarg1;
15443   if (!jarg2) {
15444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15445     return ;
15446   }
15447   std::string arg2_str(jarg2);
15448   arg2 = &arg2_str;
15449   if (arg1) (arg1)->stringKey = *arg2;
15450
15451   //argout typemap for const std::string&
15452
15453 }
15454
15455
15456 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15457   char * jresult ;
15458   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15459   std::string *result = 0 ;
15460
15461   arg1 = (Dali::Property::Key *)jarg1;
15462   result = (std::string *) & ((arg1)->stringKey);
15463   jresult = SWIG_csharp_string_callback(result->c_str());
15464   return jresult;
15465 }
15466
15467
15468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15469   void * jresult ;
15470   std::string *arg1 = 0 ;
15471   Dali::Property::Key *result = 0 ;
15472
15473   if (!jarg1) {
15474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15475     return 0;
15476   }
15477   std::string arg1_str(jarg1);
15478   arg1 = &arg1_str;
15479   {
15480     try {
15481       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15482     } catch (std::out_of_range& e) {
15483       {
15484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15485       };
15486     } catch (std::exception& e) {
15487       {
15488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15489       };
15490     } catch (Dali::DaliException e) {
15491       {
15492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15493       };
15494     } catch (...) {
15495       {
15496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15497       };
15498     }
15499   }
15500
15501   jresult = (void *)result;
15502
15503   //argout typemap for const std::string&
15504
15505   return jresult;
15506 }
15507
15508
15509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15510   void * jresult ;
15511   Dali::Property::Index arg1 ;
15512   Dali::Property::Key *result = 0 ;
15513
15514   arg1 = (Dali::Property::Index)jarg1;
15515   {
15516     try {
15517       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15518     } catch (std::out_of_range& e) {
15519       {
15520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15521       };
15522     } catch (std::exception& e) {
15523       {
15524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15525       };
15526     } catch (Dali::DaliException e) {
15527       {
15528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15529       };
15530     } catch (...) {
15531       {
15532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15533       };
15534     }
15535   }
15536
15537   jresult = (void *)result;
15538   return jresult;
15539 }
15540
15541
15542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15543   unsigned int jresult ;
15544   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15545   std::string *arg2 = 0 ;
15546   bool result;
15547
15548   arg1 = (Dali::Property::Key *)jarg1;
15549   if (!jarg2) {
15550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15551     return 0;
15552   }
15553   std::string arg2_str(jarg2);
15554   arg2 = &arg2_str;
15555   {
15556     try {
15557       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15558     } catch (std::out_of_range& e) {
15559       {
15560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15561       };
15562     } catch (std::exception& e) {
15563       {
15564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15565       };
15566     } catch (Dali::DaliException e) {
15567       {
15568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15569       };
15570     } catch (...) {
15571       {
15572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15573       };
15574     }
15575   }
15576
15577   jresult = result;
15578
15579   //argout typemap for const std::string&
15580
15581   return jresult;
15582 }
15583
15584
15585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15586   unsigned int jresult ;
15587   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15588   Dali::Property::Index arg2 ;
15589   bool result;
15590
15591   arg1 = (Dali::Property::Key *)jarg1;
15592   arg2 = (Dali::Property::Index)jarg2;
15593   {
15594     try {
15595       result = (bool)(arg1)->operator ==(arg2);
15596     } catch (std::out_of_range& e) {
15597       {
15598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15599       };
15600     } catch (std::exception& e) {
15601       {
15602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15603       };
15604     } catch (Dali::DaliException e) {
15605       {
15606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15607       };
15608     } catch (...) {
15609       {
15610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15611       };
15612     }
15613   }
15614
15615   jresult = result;
15616   return jresult;
15617 }
15618
15619
15620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15621   unsigned int jresult ;
15622   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15623   Dali::Property::Key *arg2 = 0 ;
15624   bool result;
15625
15626   arg1 = (Dali::Property::Key *)jarg1;
15627   arg2 = (Dali::Property::Key *)jarg2;
15628   if (!arg2) {
15629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15630     return 0;
15631   }
15632   {
15633     try {
15634       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15635     } catch (std::out_of_range& e) {
15636       {
15637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15638       };
15639     } catch (std::exception& e) {
15640       {
15641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15642       };
15643     } catch (Dali::DaliException e) {
15644       {
15645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15646       };
15647     } catch (...) {
15648       {
15649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15650       };
15651     }
15652   }
15653
15654   jresult = result;
15655   return jresult;
15656 }
15657
15658
15659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15660   unsigned int jresult ;
15661   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15662   std::string *arg2 = 0 ;
15663   bool result;
15664
15665   arg1 = (Dali::Property::Key *)jarg1;
15666   if (!jarg2) {
15667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15668     return 0;
15669   }
15670   std::string arg2_str(jarg2);
15671   arg2 = &arg2_str;
15672   {
15673     try {
15674       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15675     } catch (std::out_of_range& e) {
15676       {
15677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15678       };
15679     } catch (std::exception& e) {
15680       {
15681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15682       };
15683     } catch (Dali::DaliException e) {
15684       {
15685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15686       };
15687     } catch (...) {
15688       {
15689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15690       };
15691     }
15692   }
15693
15694   jresult = result;
15695
15696   //argout typemap for const std::string&
15697
15698   return jresult;
15699 }
15700
15701
15702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15703   unsigned int jresult ;
15704   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15705   Dali::Property::Index arg2 ;
15706   bool result;
15707
15708   arg1 = (Dali::Property::Key *)jarg1;
15709   arg2 = (Dali::Property::Index)jarg2;
15710   {
15711     try {
15712       result = (bool)(arg1)->operator !=(arg2);
15713     } catch (std::out_of_range& e) {
15714       {
15715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15716       };
15717     } catch (std::exception& e) {
15718       {
15719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15720       };
15721     } catch (Dali::DaliException e) {
15722       {
15723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15724       };
15725     } catch (...) {
15726       {
15727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15728       };
15729     }
15730   }
15731
15732   jresult = result;
15733   return jresult;
15734 }
15735
15736
15737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15738   unsigned int jresult ;
15739   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15740   Dali::Property::Key *arg2 = 0 ;
15741   bool result;
15742
15743   arg1 = (Dali::Property::Key *)jarg1;
15744   arg2 = (Dali::Property::Key *)jarg2;
15745   if (!arg2) {
15746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15747     return 0;
15748   }
15749   {
15750     try {
15751       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15752     } catch (std::out_of_range& e) {
15753       {
15754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15755       };
15756     } catch (std::exception& e) {
15757       {
15758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15759       };
15760     } catch (Dali::DaliException e) {
15761       {
15762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15763       };
15764     } catch (...) {
15765       {
15766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15767       };
15768     }
15769   }
15770
15771   jresult = result;
15772   return jresult;
15773 }
15774
15775
15776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15777   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15778
15779   arg1 = (Dali::Property::Key *)jarg1;
15780   {
15781     try {
15782       delete arg1;
15783     } catch (std::out_of_range& e) {
15784       {
15785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15786       };
15787     } catch (std::exception& e) {
15788       {
15789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15790       };
15791     } catch (Dali::DaliException e) {
15792       {
15793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15794       };
15795     } catch (...) {
15796       {
15797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15798       };
15799     }
15800   }
15801
15802 }
15803
15804
15805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15806   void * jresult ;
15807   Dali::Property::Map *result = 0 ;
15808
15809   {
15810     try {
15811       result = (Dali::Property::Map *)new Dali::Property::Map();
15812     } catch (std::out_of_range& e) {
15813       {
15814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15815       };
15816     } catch (std::exception& e) {
15817       {
15818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15819       };
15820     } catch (Dali::DaliException e) {
15821       {
15822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15823       };
15824     } catch (...) {
15825       {
15826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15827       };
15828     }
15829   }
15830
15831   jresult = (void *)result;
15832   return jresult;
15833 }
15834
15835
15836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15837   void * jresult ;
15838   Dali::Property::Map *arg1 = 0 ;
15839   Dali::Property::Map *result = 0 ;
15840
15841   arg1 = (Dali::Property::Map *)jarg1;
15842   if (!arg1) {
15843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15844     return 0;
15845   }
15846   {
15847     try {
15848       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15849     } catch (std::out_of_range& e) {
15850       {
15851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15852       };
15853     } catch (std::exception& e) {
15854       {
15855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15856       };
15857     } catch (Dali::DaliException e) {
15858       {
15859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15860       };
15861     } catch (...) {
15862       {
15863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15864       };
15865     }
15866   }
15867
15868   jresult = (void *)result;
15869   return jresult;
15870 }
15871
15872
15873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15874   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15875
15876   arg1 = (Dali::Property::Map *)jarg1;
15877   {
15878     try {
15879       delete arg1;
15880     } catch (std::out_of_range& e) {
15881       {
15882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15883       };
15884     } catch (std::exception& e) {
15885       {
15886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15887       };
15888     } catch (Dali::DaliException e) {
15889       {
15890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15891       };
15892     } catch (...) {
15893       {
15894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15895       };
15896     }
15897   }
15898
15899 }
15900
15901
15902 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15903   unsigned long jresult ;
15904   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15905   Dali::Property::Map::SizeType result;
15906
15907   arg1 = (Dali::Property::Map *)jarg1;
15908   {
15909     try {
15910       result = ((Dali::Property::Map const *)arg1)->Count();
15911     } catch (std::out_of_range& e) {
15912       {
15913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15914       };
15915     } catch (std::exception& e) {
15916       {
15917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15918       };
15919     } catch (Dali::DaliException e) {
15920       {
15921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15922       };
15923     } catch (...) {
15924       {
15925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15926       };
15927     }
15928   }
15929
15930   jresult = (unsigned long)result;
15931   return jresult;
15932 }
15933
15934
15935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15936   unsigned int jresult ;
15937   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15938   bool result;
15939
15940   arg1 = (Dali::Property::Map *)jarg1;
15941   {
15942     try {
15943       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15944     } catch (std::out_of_range& e) {
15945       {
15946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15947       };
15948     } catch (std::exception& e) {
15949       {
15950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15951       };
15952     } catch (Dali::DaliException e) {
15953       {
15954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15955       };
15956     } catch (...) {
15957       {
15958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15959       };
15960     }
15961   }
15962
15963   jresult = result;
15964   return jresult;
15965 }
15966
15967
15968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15969   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15970   char *arg2 = (char *) 0 ;
15971   Dali::Property::Value *arg3 = 0 ;
15972
15973   arg1 = (Dali::Property::Map *)jarg1;
15974   arg2 = (char *)jarg2;
15975   arg3 = (Dali::Property::Value *)jarg3;
15976   if (!arg3) {
15977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15978     return ;
15979   }
15980   {
15981     try {
15982       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15983     } catch (std::out_of_range& e) {
15984       {
15985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15986       };
15987     } catch (std::exception& e) {
15988       {
15989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15990       };
15991     } catch (Dali::DaliException e) {
15992       {
15993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15994       };
15995     } catch (...) {
15996       {
15997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15998       };
15999     }
16000   }
16001
16002 }
16003
16004
16005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16006   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16007   Dali::Property::Index arg2 ;
16008   Dali::Property::Value *arg3 = 0 ;
16009
16010   arg1 = (Dali::Property::Map *)jarg1;
16011   arg2 = (Dali::Property::Index)jarg2;
16012   arg3 = (Dali::Property::Value *)jarg3;
16013   if (!arg3) {
16014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16015     return ;
16016   }
16017   {
16018     try {
16019       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16020     } catch (std::out_of_range& e) {
16021       {
16022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16023       };
16024     } catch (std::exception& e) {
16025       {
16026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16027       };
16028     } catch (Dali::DaliException e) {
16029       {
16030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16031       };
16032     } catch (...) {
16033       {
16034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16035       };
16036     }
16037   }
16038
16039 }
16040
16041
16042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16043   void * jresult ;
16044   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16045   char *arg2 = (char *) 0 ;
16046   Dali::Property::Value *arg3 = 0 ;
16047   Dali::Property::Map *result = 0 ;
16048
16049   arg1 = (Dali::Property::Map *)jarg1;
16050   arg2 = (char *)jarg2;
16051   arg3 = (Dali::Property::Value *)jarg3;
16052   if (!arg3) {
16053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16054     return 0;
16055   }
16056   {
16057     try {
16058       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16059     } catch (std::out_of_range& e) {
16060       {
16061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16062       };
16063     } catch (std::exception& e) {
16064       {
16065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16066       };
16067     } catch (Dali::DaliException e) {
16068       {
16069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16070       };
16071     } catch (...) {
16072       {
16073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16074       };
16075     }
16076   }
16077
16078   jresult = (void *)result;
16079   return jresult;
16080 }
16081
16082
16083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16084   void * jresult ;
16085   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16086   Dali::Property::Index arg2 ;
16087   Dali::Property::Value *arg3 = 0 ;
16088   Dali::Property::Map *result = 0 ;
16089
16090   arg1 = (Dali::Property::Map *)jarg1;
16091   arg2 = (Dali::Property::Index)jarg2;
16092   arg3 = (Dali::Property::Value *)jarg3;
16093   if (!arg3) {
16094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16095     return 0;
16096   }
16097   {
16098     try {
16099       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16100     } catch (std::out_of_range& e) {
16101       {
16102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16103       };
16104     } catch (std::exception& e) {
16105       {
16106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16107       };
16108     } catch (Dali::DaliException e) {
16109       {
16110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16111       };
16112     } catch (...) {
16113       {
16114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16115       };
16116     }
16117   }
16118
16119   jresult = (void *)result;
16120   return jresult;
16121 }
16122
16123
16124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16125   void * jresult ;
16126   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16127   Dali::Property::Map::SizeType arg2 ;
16128   Dali::Property::Value *result = 0 ;
16129
16130   arg1 = (Dali::Property::Map *)jarg1;
16131   arg2 = (Dali::Property::Map::SizeType)jarg2;
16132   {
16133     try {
16134       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16135     } catch (std::out_of_range& e) {
16136       {
16137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16138       };
16139     } catch (std::exception& e) {
16140       {
16141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16142       };
16143     } catch (Dali::DaliException e) {
16144       {
16145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16146       };
16147     } catch (...) {
16148       {
16149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16150       };
16151     }
16152   }
16153
16154   jresult = (void *)result;
16155   return jresult;
16156 }
16157
16158
16159 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16160   char * jresult ;
16161   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16162   Dali::Property::Map::SizeType arg2 ;
16163   std::string *result = 0 ;
16164
16165   arg1 = (Dali::Property::Map *)jarg1;
16166   arg2 = (Dali::Property::Map::SizeType)jarg2;
16167   {
16168     try {
16169       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16170     } catch (std::out_of_range& e) {
16171       {
16172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16173       };
16174     } catch (std::exception& e) {
16175       {
16176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16177       };
16178     } catch (Dali::DaliException e) {
16179       {
16180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16181       };
16182     } catch (...) {
16183       {
16184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16185       };
16186     }
16187   }
16188
16189   jresult = SWIG_csharp_string_callback(result->c_str());
16190   return jresult;
16191 }
16192
16193
16194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16195   void * jresult ;
16196   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16197   Dali::Property::Map::SizeType arg2 ;
16198   SwigValueWrapper< Dali::Property::Key > result;
16199
16200   arg1 = (Dali::Property::Map *)jarg1;
16201   arg2 = (Dali::Property::Map::SizeType)jarg2;
16202   {
16203     try {
16204       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16205     } catch (std::out_of_range& e) {
16206       {
16207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16208       };
16209     } catch (std::exception& e) {
16210       {
16211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16212       };
16213     } catch (Dali::DaliException e) {
16214       {
16215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16216       };
16217     } catch (...) {
16218       {
16219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16220       };
16221     }
16222   }
16223
16224   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16225   return jresult;
16226 }
16227
16228
16229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16230   void * jresult ;
16231   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16232   Dali::Property::Map::SizeType arg2 ;
16233   StringValuePair *result = 0 ;
16234
16235   arg1 = (Dali::Property::Map *)jarg1;
16236   arg2 = (Dali::Property::Map::SizeType)jarg2;
16237   {
16238     try {
16239       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16240     } catch (std::out_of_range& e) {
16241       {
16242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16243       };
16244     } catch (std::exception& e) {
16245       {
16246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16247       };
16248     } catch (Dali::DaliException e) {
16249       {
16250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16251       };
16252     } catch (...) {
16253       {
16254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16255       };
16256     }
16257   }
16258
16259   jresult = (void *)result;
16260   return jresult;
16261 }
16262
16263
16264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16265   void * jresult ;
16266   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16267   char *arg2 = (char *) 0 ;
16268   Dali::Property::Value *result = 0 ;
16269
16270   arg1 = (Dali::Property::Map *)jarg1;
16271   arg2 = (char *)jarg2;
16272   {
16273     try {
16274       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16275     } catch (std::out_of_range& e) {
16276       {
16277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16278       };
16279     } catch (std::exception& e) {
16280       {
16281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16282       };
16283     } catch (Dali::DaliException e) {
16284       {
16285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16286       };
16287     } catch (...) {
16288       {
16289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16290       };
16291     }
16292   }
16293
16294   jresult = (void *)result;
16295   return jresult;
16296 }
16297
16298
16299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16300   void * jresult ;
16301   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16302   Dali::Property::Index arg2 ;
16303   Dali::Property::Value *result = 0 ;
16304
16305   arg1 = (Dali::Property::Map *)jarg1;
16306   arg2 = (Dali::Property::Index)jarg2;
16307   {
16308     try {
16309       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16310     } catch (std::out_of_range& e) {
16311       {
16312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16313       };
16314     } catch (std::exception& e) {
16315       {
16316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16317       };
16318     } catch (Dali::DaliException e) {
16319       {
16320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16321       };
16322     } catch (...) {
16323       {
16324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16325       };
16326     }
16327   }
16328
16329   jresult = (void *)result;
16330   return jresult;
16331 }
16332
16333
16334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16335   void * jresult ;
16336   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16337   Dali::Property::Index arg2 ;
16338   std::string *arg3 = 0 ;
16339   Dali::Property::Value *result = 0 ;
16340
16341   arg1 = (Dali::Property::Map *)jarg1;
16342   arg2 = (Dali::Property::Index)jarg2;
16343   if (!jarg3) {
16344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16345     return 0;
16346   }
16347   std::string arg3_str(jarg3);
16348   arg3 = &arg3_str;
16349   {
16350     try {
16351       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16352     } catch (std::out_of_range& e) {
16353       {
16354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16355       };
16356     } catch (std::exception& e) {
16357       {
16358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16359       };
16360     } catch (Dali::DaliException e) {
16361       {
16362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16363       };
16364     } catch (...) {
16365       {
16366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16367       };
16368     }
16369   }
16370
16371   jresult = (void *)result;
16372
16373   //argout typemap for const std::string&
16374
16375   return jresult;
16376 }
16377
16378
16379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16380   void * jresult ;
16381   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16382   std::string *arg2 = 0 ;
16383   Dali::Property::Type arg3 ;
16384   Dali::Property::Value *result = 0 ;
16385
16386   arg1 = (Dali::Property::Map *)jarg1;
16387   if (!jarg2) {
16388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16389     return 0;
16390   }
16391   std::string arg2_str(jarg2);
16392   arg2 = &arg2_str;
16393   arg3 = (Dali::Property::Type)jarg3;
16394   {
16395     try {
16396       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16397     } catch (std::out_of_range& e) {
16398       {
16399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16400       };
16401     } catch (std::exception& e) {
16402       {
16403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16404       };
16405     } catch (Dali::DaliException e) {
16406       {
16407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16408       };
16409     } catch (...) {
16410       {
16411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16412       };
16413     }
16414   }
16415
16416   jresult = (void *)result;
16417
16418   //argout typemap for const std::string&
16419
16420   return jresult;
16421 }
16422
16423
16424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16425   void * jresult ;
16426   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16427   Dali::Property::Index arg2 ;
16428   Dali::Property::Type arg3 ;
16429   Dali::Property::Value *result = 0 ;
16430
16431   arg1 = (Dali::Property::Map *)jarg1;
16432   arg2 = (Dali::Property::Index)jarg2;
16433   arg3 = (Dali::Property::Type)jarg3;
16434   {
16435     try {
16436       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16437     } catch (std::out_of_range& e) {
16438       {
16439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16440       };
16441     } catch (std::exception& e) {
16442       {
16443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16444       };
16445     } catch (Dali::DaliException e) {
16446       {
16447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16448       };
16449     } catch (...) {
16450       {
16451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16452       };
16453     }
16454   }
16455
16456   jresult = (void *)result;
16457   return jresult;
16458 }
16459
16460
16461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16462   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16463
16464   arg1 = (Dali::Property::Map *)jarg1;
16465   {
16466     try {
16467       (arg1)->Clear();
16468     } catch (std::out_of_range& e) {
16469       {
16470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16471       };
16472     } catch (std::exception& e) {
16473       {
16474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16475       };
16476     } catch (Dali::DaliException e) {
16477       {
16478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16479       };
16480     } catch (...) {
16481       {
16482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16483       };
16484     }
16485   }
16486
16487 }
16488
16489
16490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16491   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16492   Dali::Property::Map *arg2 = 0 ;
16493
16494   arg1 = (Dali::Property::Map *)jarg1;
16495   arg2 = (Dali::Property::Map *)jarg2;
16496   if (!arg2) {
16497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16498     return ;
16499   }
16500   {
16501     try {
16502       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16503     } catch (std::out_of_range& e) {
16504       {
16505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16506       };
16507     } catch (std::exception& e) {
16508       {
16509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16510       };
16511     } catch (Dali::DaliException e) {
16512       {
16513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16514       };
16515     } catch (...) {
16516       {
16517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16518       };
16519     }
16520   }
16521
16522 }
16523
16524
16525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16526   void * jresult ;
16527   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16528   std::string *arg2 = 0 ;
16529   Dali::Property::Value *result = 0 ;
16530
16531   arg1 = (Dali::Property::Map *)jarg1;
16532   if (!jarg2) {
16533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16534     return 0;
16535   }
16536   std::string arg2_str(jarg2);
16537   arg2 = &arg2_str;
16538   {
16539     try {
16540       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16541     } catch (std::out_of_range& e) {
16542       {
16543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16544       };
16545     } catch (std::exception& e) {
16546       {
16547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16548       };
16549     } catch (Dali::DaliException e) {
16550       {
16551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16552       };
16553     } catch (...) {
16554       {
16555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16556       };
16557     }
16558   }
16559
16560   jresult = (void *)result;
16561
16562   //argout typemap for const std::string&
16563
16564   return jresult;
16565 }
16566
16567
16568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16569   void * jresult ;
16570   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16571   Dali::Property::Index arg2 ;
16572   Dali::Property::Value *result = 0 ;
16573
16574   arg1 = (Dali::Property::Map *)jarg1;
16575   arg2 = (Dali::Property::Index)jarg2;
16576   {
16577     try {
16578       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16579     } catch (std::out_of_range& e) {
16580       {
16581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16582       };
16583     } catch (std::exception& e) {
16584       {
16585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16586       };
16587     } catch (Dali::DaliException e) {
16588       {
16589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16590       };
16591     } catch (...) {
16592       {
16593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16594       };
16595     }
16596   }
16597
16598   jresult = (void *)result;
16599   return jresult;
16600 }
16601
16602
16603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16604   void * jresult ;
16605   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16606   Dali::Property::Map *arg2 = 0 ;
16607   Dali::Property::Map *result = 0 ;
16608
16609   arg1 = (Dali::Property::Map *)jarg1;
16610   arg2 = (Dali::Property::Map *)jarg2;
16611   if (!arg2) {
16612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16613     return 0;
16614   }
16615   {
16616     try {
16617       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16618     } catch (std::out_of_range& e) {
16619       {
16620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16621       };
16622     } catch (std::exception& e) {
16623       {
16624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16625       };
16626     } catch (Dali::DaliException e) {
16627       {
16628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16629       };
16630     } catch (...) {
16631       {
16632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16633       };
16634     }
16635   }
16636
16637   jresult = (void *)result;
16638   return jresult;
16639 }
16640
16641
16642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16643   void * jresult ;
16644   Dali::Property::Value *result = 0 ;
16645
16646   {
16647     try {
16648       result = (Dali::Property::Value *)new Dali::Property::Value();
16649     } catch (std::out_of_range& e) {
16650       {
16651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16652       };
16653     } catch (std::exception& e) {
16654       {
16655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16656       };
16657     } catch (Dali::DaliException e) {
16658       {
16659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16660       };
16661     } catch (...) {
16662       {
16663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16664       };
16665     }
16666   }
16667
16668   jresult = (void *)result;
16669   return jresult;
16670 }
16671
16672
16673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16674   void * jresult ;
16675   bool arg1 ;
16676   Dali::Property::Value *result = 0 ;
16677
16678   arg1 = jarg1 ? true : false;
16679   {
16680     try {
16681       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16682     } catch (std::out_of_range& e) {
16683       {
16684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16685       };
16686     } catch (std::exception& e) {
16687       {
16688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16689       };
16690     } catch (Dali::DaliException e) {
16691       {
16692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16693       };
16694     } catch (...) {
16695       {
16696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16697       };
16698     }
16699   }
16700
16701   jresult = (void *)result;
16702   return jresult;
16703 }
16704
16705
16706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16707   void * jresult ;
16708   int arg1 ;
16709   Dali::Property::Value *result = 0 ;
16710
16711   arg1 = (int)jarg1;
16712   {
16713     try {
16714       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16715     } catch (std::out_of_range& e) {
16716       {
16717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16718       };
16719     } catch (std::exception& e) {
16720       {
16721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16722       };
16723     } catch (Dali::DaliException e) {
16724       {
16725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16726       };
16727     } catch (...) {
16728       {
16729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16730       };
16731     }
16732   }
16733
16734   jresult = (void *)result;
16735   return jresult;
16736 }
16737
16738
16739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16740   void * jresult ;
16741   float arg1 ;
16742   Dali::Property::Value *result = 0 ;
16743
16744   arg1 = (float)jarg1;
16745   {
16746     try {
16747       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16748     } catch (std::out_of_range& e) {
16749       {
16750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16751       };
16752     } catch (std::exception& e) {
16753       {
16754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16755       };
16756     } catch (Dali::DaliException e) {
16757       {
16758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16759       };
16760     } catch (...) {
16761       {
16762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16763       };
16764     }
16765   }
16766
16767   jresult = (void *)result;
16768   return jresult;
16769 }
16770
16771
16772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16773   void * jresult ;
16774   Dali::Vector2 *arg1 = 0 ;
16775   Dali::Property::Value *result = 0 ;
16776
16777   arg1 = (Dali::Vector2 *)jarg1;
16778   if (!arg1) {
16779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16780     return 0;
16781   }
16782   {
16783     try {
16784       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16785     } catch (std::out_of_range& e) {
16786       {
16787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16788       };
16789     } catch (std::exception& e) {
16790       {
16791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16792       };
16793     } catch (Dali::DaliException e) {
16794       {
16795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16796       };
16797     } catch (...) {
16798       {
16799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16800       };
16801     }
16802   }
16803
16804   jresult = (void *)result;
16805   return jresult;
16806 }
16807
16808
16809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16810   void * jresult ;
16811   Dali::Vector3 *arg1 = 0 ;
16812   Dali::Property::Value *result = 0 ;
16813
16814   arg1 = (Dali::Vector3 *)jarg1;
16815   if (!arg1) {
16816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16817     return 0;
16818   }
16819   {
16820     try {
16821       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16822     } catch (std::out_of_range& e) {
16823       {
16824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16825       };
16826     } catch (std::exception& e) {
16827       {
16828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16829       };
16830     } catch (Dali::DaliException e) {
16831       {
16832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16833       };
16834     } catch (...) {
16835       {
16836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16837       };
16838     }
16839   }
16840
16841   jresult = (void *)result;
16842   return jresult;
16843 }
16844
16845
16846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16847   void * jresult ;
16848   Dali::Vector4 *arg1 = 0 ;
16849   Dali::Property::Value *result = 0 ;
16850
16851   arg1 = (Dali::Vector4 *)jarg1;
16852   if (!arg1) {
16853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16854     return 0;
16855   }
16856   {
16857     try {
16858       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16859     } catch (std::out_of_range& e) {
16860       {
16861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16862       };
16863     } catch (std::exception& e) {
16864       {
16865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16866       };
16867     } catch (Dali::DaliException e) {
16868       {
16869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16870       };
16871     } catch (...) {
16872       {
16873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16874       };
16875     }
16876   }
16877
16878   jresult = (void *)result;
16879   return jresult;
16880 }
16881
16882
16883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16884   void * jresult ;
16885   Dali::Matrix3 *arg1 = 0 ;
16886   Dali::Property::Value *result = 0 ;
16887
16888   arg1 = (Dali::Matrix3 *)jarg1;
16889   if (!arg1) {
16890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16891     return 0;
16892   }
16893   {
16894     try {
16895       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16896     } catch (std::out_of_range& e) {
16897       {
16898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16899       };
16900     } catch (std::exception& e) {
16901       {
16902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16903       };
16904     } catch (Dali::DaliException e) {
16905       {
16906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16907       };
16908     } catch (...) {
16909       {
16910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16911       };
16912     }
16913   }
16914
16915   jresult = (void *)result;
16916   return jresult;
16917 }
16918
16919
16920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16921   void * jresult ;
16922   Dali::Matrix *arg1 = 0 ;
16923   Dali::Property::Value *result = 0 ;
16924
16925   arg1 = (Dali::Matrix *)jarg1;
16926   if (!arg1) {
16927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16928     return 0;
16929   }
16930   {
16931     try {
16932       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16933     } catch (std::out_of_range& e) {
16934       {
16935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16936       };
16937     } catch (std::exception& e) {
16938       {
16939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16940       };
16941     } catch (Dali::DaliException e) {
16942       {
16943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16944       };
16945     } catch (...) {
16946       {
16947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16948       };
16949     }
16950   }
16951
16952   jresult = (void *)result;
16953   return jresult;
16954 }
16955
16956
16957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16958   void * jresult ;
16959   Dali::Rect< int > *arg1 = 0 ;
16960   Dali::Property::Value *result = 0 ;
16961
16962   arg1 = (Dali::Rect< int > *)jarg1;
16963   if (!arg1) {
16964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16965     return 0;
16966   }
16967   {
16968     try {
16969       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16970     } catch (std::out_of_range& e) {
16971       {
16972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16973       };
16974     } catch (std::exception& e) {
16975       {
16976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16977       };
16978     } catch (Dali::DaliException e) {
16979       {
16980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16981       };
16982     } catch (...) {
16983       {
16984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16985       };
16986     }
16987   }
16988
16989   jresult = (void *)result;
16990   return jresult;
16991 }
16992
16993
16994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16995   void * jresult ;
16996   Dali::AngleAxis *arg1 = 0 ;
16997   Dali::Property::Value *result = 0 ;
16998
16999   arg1 = (Dali::AngleAxis *)jarg1;
17000   if (!arg1) {
17001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17002     return 0;
17003   }
17004   {
17005     try {
17006       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17007     } catch (std::out_of_range& e) {
17008       {
17009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17010       };
17011     } catch (std::exception& e) {
17012       {
17013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17014       };
17015     } catch (Dali::DaliException e) {
17016       {
17017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17018       };
17019     } catch (...) {
17020       {
17021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17022       };
17023     }
17024   }
17025
17026   jresult = (void *)result;
17027   return jresult;
17028 }
17029
17030
17031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17032   void * jresult ;
17033   Dali::Quaternion *arg1 = 0 ;
17034   Dali::Property::Value *result = 0 ;
17035
17036   arg1 = (Dali::Quaternion *)jarg1;
17037   if (!arg1) {
17038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17039     return 0;
17040   }
17041   {
17042     try {
17043       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17044     } catch (std::out_of_range& e) {
17045       {
17046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17047       };
17048     } catch (std::exception& e) {
17049       {
17050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17051       };
17052     } catch (Dali::DaliException e) {
17053       {
17054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17055       };
17056     } catch (...) {
17057       {
17058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17059       };
17060     }
17061   }
17062
17063   jresult = (void *)result;
17064   return jresult;
17065 }
17066
17067
17068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17069   void * jresult ;
17070   std::string *arg1 = 0 ;
17071   Dali::Property::Value *result = 0 ;
17072
17073   if (!jarg1) {
17074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17075     return 0;
17076   }
17077   std::string arg1_str(jarg1);
17078   arg1 = &arg1_str;
17079   {
17080     try {
17081       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
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 (Dali::DaliException e) {
17091       {
17092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17093       };
17094     } catch (...) {
17095       {
17096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17097       };
17098     }
17099   }
17100
17101   jresult = (void *)result;
17102
17103   //argout typemap for const std::string&
17104
17105   return jresult;
17106 }
17107
17108
17109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17110   void * jresult ;
17111   Dali::Property::Array *arg1 = 0 ;
17112   Dali::Property::Value *result = 0 ;
17113
17114   arg1 = (Dali::Property::Array *)jarg1;
17115   if (!arg1) {
17116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17117     return 0;
17118   }
17119   {
17120     try {
17121       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17122     } catch (std::out_of_range& e) {
17123       {
17124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17125       };
17126     } catch (std::exception& e) {
17127       {
17128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17129       };
17130     } catch (Dali::DaliException e) {
17131       {
17132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17133       };
17134     } catch (...) {
17135       {
17136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17137       };
17138     }
17139   }
17140
17141   jresult = (void *)result;
17142   return jresult;
17143 }
17144
17145
17146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17147   void * jresult ;
17148   Dali::Property::Map *arg1 = 0 ;
17149   Dali::Property::Value *result = 0 ;
17150
17151   arg1 = (Dali::Property::Map *)jarg1;
17152   if (!arg1) {
17153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17154     return 0;
17155   }
17156   {
17157     try {
17158       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17159     } catch (std::out_of_range& e) {
17160       {
17161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17162       };
17163     } catch (std::exception& e) {
17164       {
17165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (Dali::DaliException e) {
17168       {
17169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17170       };
17171     } catch (...) {
17172       {
17173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17174       };
17175     }
17176   }
17177
17178   jresult = (void *)result;
17179   return jresult;
17180 }
17181
17182
17183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17184   void * jresult ;
17185   Extents *arg1 = 0 ;
17186   Dali::Property::Value *result = 0 ;
17187
17188   arg1 = (Extents *)jarg1;
17189   if (!arg1) {
17190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17191     return 0;
17192   }
17193   {
17194     try {
17195       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*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 = (void *)result;
17211   return jresult;
17212 }
17213
17214
17215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17216   void * jresult ;
17217   Dali::Property::Type arg1 ;
17218   Dali::Property::Value *result = 0 ;
17219
17220   arg1 = (Dali::Property::Type)jarg1;
17221   {
17222     try {
17223       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17224     } catch (std::out_of_range& e) {
17225       {
17226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17227       };
17228     } catch (std::exception& e) {
17229       {
17230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17231       };
17232     } catch (Dali::DaliException e) {
17233       {
17234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17235       };
17236     } catch (...) {
17237       {
17238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17239       };
17240     }
17241   }
17242
17243   jresult = (void *)result;
17244   return jresult;
17245 }
17246
17247
17248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17249   void * jresult ;
17250   Dali::Property::Value *arg1 = 0 ;
17251   Dali::Property::Value *result = 0 ;
17252
17253   arg1 = (Dali::Property::Value *)jarg1;
17254   if (!arg1) {
17255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17256     return 0;
17257   }
17258   {
17259     try {
17260       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17261     } catch (std::out_of_range& e) {
17262       {
17263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17264       };
17265     } catch (std::exception& e) {
17266       {
17267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17268       };
17269     } catch (Dali::DaliException e) {
17270       {
17271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17272       };
17273     } catch (...) {
17274       {
17275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17276       };
17277     }
17278   }
17279
17280   jresult = (void *)result;
17281   return jresult;
17282 }
17283
17284
17285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17286   void * jresult ;
17287   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17288   Dali::Property::Value *arg2 = 0 ;
17289   Dali::Property::Value *result = 0 ;
17290
17291   arg1 = (Dali::Property::Value *)jarg1;
17292   arg2 = (Dali::Property::Value *)jarg2;
17293   if (!arg2) {
17294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17295     return 0;
17296   }
17297   {
17298     try {
17299       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17300     } catch (std::out_of_range& e) {
17301       {
17302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17303       };
17304     } catch (std::exception& e) {
17305       {
17306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (Dali::DaliException e) {
17309       {
17310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17311       };
17312     } catch (...) {
17313       {
17314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17315       };
17316     }
17317   }
17318
17319   jresult = (void *)result;
17320   return jresult;
17321 }
17322
17323
17324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17325   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17326
17327   arg1 = (Dali::Property::Value *)jarg1;
17328   {
17329     try {
17330       delete arg1;
17331     } catch (std::out_of_range& e) {
17332       {
17333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17334       };
17335     } catch (std::exception& e) {
17336       {
17337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17338       };
17339     } catch (Dali::DaliException e) {
17340       {
17341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17342       };
17343     } catch (...) {
17344       {
17345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17346       };
17347     }
17348   }
17349
17350 }
17351
17352
17353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17354   int jresult ;
17355   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17356   Dali::Property::Type result;
17357
17358   arg1 = (Dali::Property::Value *)jarg1;
17359   {
17360     try {
17361       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17362     } catch (std::out_of_range& e) {
17363       {
17364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17365       };
17366     } catch (std::exception& e) {
17367       {
17368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17369       };
17370     } catch (Dali::DaliException e) {
17371       {
17372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17373       };
17374     } catch (...) {
17375       {
17376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17377       };
17378     }
17379   }
17380
17381   jresult = (int)result;
17382   return jresult;
17383 }
17384
17385
17386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17387   unsigned int jresult ;
17388   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17389   bool *arg2 = 0 ;
17390   bool result;
17391
17392   arg1 = (Dali::Property::Value *)jarg1;
17393   arg2 = (bool *)jarg2;
17394   {
17395     try {
17396       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17397     } catch (std::out_of_range& e) {
17398       {
17399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17400       };
17401     } catch (std::exception& e) {
17402       {
17403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17404       };
17405     } catch (Dali::DaliException e) {
17406       {
17407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17408       };
17409     } catch (...) {
17410       {
17411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17412       };
17413     }
17414   }
17415
17416   jresult = result;
17417   return jresult;
17418 }
17419
17420
17421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17422   unsigned int jresult ;
17423   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17424   float *arg2 = 0 ;
17425   bool result;
17426
17427   arg1 = (Dali::Property::Value *)jarg1;
17428   arg2 = (float *)jarg2;
17429   {
17430     try {
17431       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17432     } catch (std::out_of_range& e) {
17433       {
17434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17435       };
17436     } catch (std::exception& e) {
17437       {
17438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17439       };
17440     } catch (Dali::DaliException e) {
17441       {
17442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17443       };
17444     } catch (...) {
17445       {
17446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17447       };
17448     }
17449   }
17450
17451   jresult = result;
17452   return jresult;
17453 }
17454
17455
17456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17457   unsigned int jresult ;
17458   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17459   int *arg2 = 0 ;
17460   bool result;
17461
17462   arg1 = (Dali::Property::Value *)jarg1;
17463   arg2 = (int *)jarg2;
17464   {
17465     try {
17466       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17467     } catch (std::out_of_range& e) {
17468       {
17469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17470       };
17471     } catch (std::exception& e) {
17472       {
17473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17474       };
17475     } catch (Dali::DaliException e) {
17476       {
17477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17478       };
17479     } catch (...) {
17480       {
17481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17482       };
17483     }
17484   }
17485
17486   jresult = result;
17487   return jresult;
17488 }
17489
17490
17491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17492   unsigned int jresult ;
17493   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17494   Dali::Rect< int > *arg2 = 0 ;
17495   bool result;
17496
17497   arg1 = (Dali::Property::Value *)jarg1;
17498   arg2 = (Dali::Rect< int > *)jarg2;
17499   if (!arg2) {
17500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17501     return 0;
17502   }
17503   {
17504     try {
17505       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17506     } catch (std::out_of_range& e) {
17507       {
17508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17509       };
17510     } catch (std::exception& e) {
17511       {
17512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17513       };
17514     } catch (Dali::DaliException e) {
17515       {
17516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17517       };
17518     } catch (...) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17521       };
17522     }
17523   }
17524
17525   jresult = result;
17526   return jresult;
17527 }
17528
17529
17530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17531   unsigned int jresult ;
17532   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17533   Dali::Vector2 *arg2 = 0 ;
17534   bool result;
17535
17536   arg1 = (Dali::Property::Value *)jarg1;
17537   arg2 = (Dali::Vector2 *)jarg2;
17538   if (!arg2) {
17539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17540     return 0;
17541   }
17542   {
17543     try {
17544       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17545     } catch (std::out_of_range& e) {
17546       {
17547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17548       };
17549     } catch (std::exception& e) {
17550       {
17551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17552       };
17553     } catch (Dali::DaliException e) {
17554       {
17555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17556       };
17557     } catch (...) {
17558       {
17559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17560       };
17561     }
17562   }
17563
17564   jresult = result;
17565   return jresult;
17566 }
17567
17568
17569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17570   unsigned int jresult ;
17571   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17572   Dali::Vector3 *arg2 = 0 ;
17573   bool result;
17574
17575   arg1 = (Dali::Property::Value *)jarg1;
17576   arg2 = (Dali::Vector3 *)jarg2;
17577   if (!arg2) {
17578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17579     return 0;
17580   }
17581   {
17582     try {
17583       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17584     } catch (std::out_of_range& e) {
17585       {
17586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17587       };
17588     } catch (std::exception& e) {
17589       {
17590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17591       };
17592     } catch (Dali::DaliException e) {
17593       {
17594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17595       };
17596     } catch (...) {
17597       {
17598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17599       };
17600     }
17601   }
17602
17603   jresult = result;
17604   return jresult;
17605 }
17606
17607
17608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17609   unsigned int jresult ;
17610   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17611   Dali::Vector4 *arg2 = 0 ;
17612   bool result;
17613
17614   arg1 = (Dali::Property::Value *)jarg1;
17615   arg2 = (Dali::Vector4 *)jarg2;
17616   if (!arg2) {
17617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17618     return 0;
17619   }
17620   {
17621     try {
17622       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17623     } catch (std::out_of_range& e) {
17624       {
17625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17626       };
17627     } catch (std::exception& e) {
17628       {
17629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17630       };
17631     } catch (Dali::DaliException e) {
17632       {
17633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17634       };
17635     } catch (...) {
17636       {
17637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17638       };
17639     }
17640   }
17641
17642   jresult = result;
17643   return jresult;
17644 }
17645
17646
17647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17648   unsigned int jresult ;
17649   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17650   Dali::Matrix3 *arg2 = 0 ;
17651   bool result;
17652
17653   arg1 = (Dali::Property::Value *)jarg1;
17654   arg2 = (Dali::Matrix3 *)jarg2;
17655   if (!arg2) {
17656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17657     return 0;
17658   }
17659   {
17660     try {
17661       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
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 (Dali::DaliException e) {
17671       {
17672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17673       };
17674     } catch (...) {
17675       {
17676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17677       };
17678     }
17679   }
17680
17681   jresult = result;
17682   return jresult;
17683 }
17684
17685
17686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17687   unsigned int jresult ;
17688   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17689   Dali::Matrix *arg2 = 0 ;
17690   bool result;
17691
17692   arg1 = (Dali::Property::Value *)jarg1;
17693   arg2 = (Dali::Matrix *)jarg2;
17694   if (!arg2) {
17695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17696     return 0;
17697   }
17698   {
17699     try {
17700       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17701     } catch (std::out_of_range& e) {
17702       {
17703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17704       };
17705     } catch (std::exception& e) {
17706       {
17707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17708       };
17709     } catch (Dali::DaliException e) {
17710       {
17711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17712       };
17713     } catch (...) {
17714       {
17715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17716       };
17717     }
17718   }
17719
17720   jresult = result;
17721   return jresult;
17722 }
17723
17724
17725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17726   unsigned int jresult ;
17727   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17728   Dali::AngleAxis *arg2 = 0 ;
17729   bool result;
17730
17731   arg1 = (Dali::Property::Value *)jarg1;
17732   arg2 = (Dali::AngleAxis *)jarg2;
17733   if (!arg2) {
17734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17735     return 0;
17736   }
17737   {
17738     try {
17739       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17740     } catch (std::out_of_range& e) {
17741       {
17742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17743       };
17744     } catch (std::exception& e) {
17745       {
17746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17747       };
17748     } catch (Dali::DaliException e) {
17749       {
17750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17751       };
17752     } catch (...) {
17753       {
17754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17755       };
17756     }
17757   }
17758
17759   jresult = result;
17760   return jresult;
17761 }
17762
17763
17764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17765   unsigned int jresult ;
17766   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17767   Dali::Quaternion *arg2 = 0 ;
17768   bool result;
17769
17770   arg1 = (Dali::Property::Value *)jarg1;
17771   arg2 = (Dali::Quaternion *)jarg2;
17772   if (!arg2) {
17773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17774     return 0;
17775   }
17776   {
17777     try {
17778       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17779     } catch (std::out_of_range& e) {
17780       {
17781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17782       };
17783     } catch (std::exception& e) {
17784       {
17785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17786       };
17787     } catch (Dali::DaliException e) {
17788       {
17789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17790       };
17791     } catch (...) {
17792       {
17793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17794       };
17795     }
17796   }
17797
17798   jresult = result;
17799   return jresult;
17800 }
17801
17802
17803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17804   unsigned int jresult ;
17805   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17806   std::string *arg2 = 0 ;
17807   bool result;
17808
17809   arg1 = (Dali::Property::Value *)jarg1;
17810
17811   //typemap in
17812   std::string temp;
17813   arg2 = &temp;
17814
17815   {
17816     try {
17817       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17818     } catch (std::out_of_range& e) {
17819       {
17820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17821       };
17822     } catch (std::exception& e) {
17823       {
17824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17825       };
17826     } catch (Dali::DaliException e) {
17827       {
17828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17829       };
17830     } catch (...) {
17831       {
17832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17833       };
17834     }
17835   }
17836
17837   jresult = result;
17838
17839   //Typemap argout in c++ file.
17840   //This will convert c++ string to c# string
17841   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17842
17843   return jresult;
17844 }
17845
17846
17847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17848   unsigned int jresult ;
17849   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17850   Dali::Property::Array *arg2 = 0 ;
17851   bool result;
17852
17853   arg1 = (Dali::Property::Value *)jarg1;
17854   arg2 = (Dali::Property::Array *)jarg2;
17855   if (!arg2) {
17856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17857     return 0;
17858   }
17859   {
17860     try {
17861       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17862     } catch (std::out_of_range& e) {
17863       {
17864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17865       };
17866     } catch (std::exception& e) {
17867       {
17868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17869       };
17870     } catch (Dali::DaliException e) {
17871       {
17872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17873       };
17874     } catch (...) {
17875       {
17876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17877       };
17878     }
17879   }
17880
17881   jresult = result;
17882   return jresult;
17883 }
17884
17885
17886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17887   unsigned int jresult ;
17888   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17889   Dali::Property::Map *arg2 = 0 ;
17890   bool result;
17891
17892   arg1 = (Dali::Property::Value *)jarg1;
17893   arg2 = (Dali::Property::Map *)jarg2;
17894   if (!arg2) {
17895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17896     return 0;
17897   }
17898   {
17899     try {
17900       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17901     } catch (std::out_of_range& e) {
17902       {
17903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17904       };
17905     } catch (std::exception& e) {
17906       {
17907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17908       };
17909     } catch (Dali::DaliException e) {
17910       {
17911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17912       };
17913     } catch (...) {
17914       {
17915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17916       };
17917     }
17918   }
17919
17920   jresult = result;
17921   return jresult;
17922 }
17923
17924
17925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17926   unsigned int jresult ;
17927   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17928   Extents *arg2 = 0 ;
17929   bool result;
17930
17931   arg1 = (Dali::Property::Value *)jarg1;
17932   arg2 = (Extents *)jarg2;
17933   if (!arg2) {
17934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17935     return 0;
17936   }
17937   {
17938     try {
17939       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17940     } catch (std::out_of_range& e) {
17941       {
17942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17943       };
17944     } catch (std::exception& e) {
17945       {
17946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17947       };
17948     } catch (...) {
17949       {
17950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17951       };
17952     }
17953   }
17954   jresult = result;
17955   return jresult;
17956 }
17957
17958
17959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17960   void * jresult ;
17961   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17962   Dali::Property::Array *result = 0 ;
17963
17964   arg1 = (Dali::Property::Value *)jarg1;
17965   {
17966     try {
17967       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17968     } catch (std::out_of_range& e) {
17969       {
17970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17971       };
17972     } catch (std::exception& e) {
17973       {
17974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17975       };
17976     } catch (Dali::DaliException e) {
17977       {
17978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17979       };
17980     } catch (...) {
17981       {
17982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17983       };
17984     }
17985   }
17986
17987   jresult = (void *)result;
17988   return jresult;
17989 }
17990
17991
17992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17993   void * jresult ;
17994   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17995   Dali::Property::Map *result = 0 ;
17996
17997   arg1 = (Dali::Property::Value *)jarg1;
17998   {
17999     try {
18000       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18001     } catch (std::out_of_range& e) {
18002       {
18003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18004       };
18005     } catch (std::exception& e) {
18006       {
18007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18008       };
18009     } catch (Dali::DaliException e) {
18010       {
18011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18012       };
18013     } catch (...) {
18014       {
18015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18016       };
18017     }
18018   }
18019
18020   jresult = (void *)result;
18021   return jresult;
18022 }
18023
18024
18025 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18026   char * jresult ;
18027   Dali::Property::Type arg1 ;
18028   char *result = 0 ;
18029
18030   arg1 = (Dali::Property::Type)jarg1;
18031   {
18032     try {
18033       result = (char *)Dali::PropertyTypes::GetName(arg1);
18034     } catch (std::out_of_range& e) {
18035       {
18036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18037       };
18038     } catch (std::exception& e) {
18039       {
18040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18041       };
18042     } catch (Dali::DaliException e) {
18043       {
18044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18045       };
18046     } catch (...) {
18047       {
18048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18049       };
18050     }
18051   }
18052
18053   jresult = SWIG_csharp_string_callback((const char *)result);
18054   return jresult;
18055 }
18056
18057
18058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18059   unsigned int jresult ;
18060   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18061   std::string *arg2 = 0 ;
18062   Dali::Property::Map *arg3 = 0 ;
18063   bool result;
18064
18065   arg1 = (Dali::BaseObject *)jarg1;
18066   if (!jarg2) {
18067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18068     return 0;
18069   }
18070   std::string arg2_str(jarg2);
18071   arg2 = &arg2_str;
18072   arg3 = (Dali::Property::Map *)jarg3;
18073   if (!arg3) {
18074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18075     return 0;
18076   }
18077   {
18078     try {
18079       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18080     } catch (std::out_of_range& e) {
18081       {
18082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18083       };
18084     } catch (std::exception& e) {
18085       {
18086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18087       };
18088     } catch (Dali::DaliException e) {
18089       {
18090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18091       };
18092     } catch (...) {
18093       {
18094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18095       };
18096     }
18097   }
18098
18099   jresult = result;
18100
18101   //argout typemap for const std::string&
18102
18103   return jresult;
18104 }
18105
18106
18107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18108   char * jresult ;
18109   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18110   std::string *result = 0 ;
18111
18112   arg1 = (Dali::BaseObject *)jarg1;
18113   {
18114     try {
18115       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18116     } catch (std::out_of_range& e) {
18117       {
18118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18119       };
18120     } catch (std::exception& e) {
18121       {
18122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18123       };
18124     } catch (Dali::DaliException e) {
18125       {
18126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18127       };
18128     } catch (...) {
18129       {
18130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18131       };
18132     }
18133   }
18134
18135   jresult = SWIG_csharp_string_callback(result->c_str());
18136   return jresult;
18137 }
18138
18139
18140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18141   unsigned int jresult ;
18142   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18143   Dali::TypeInfo *arg2 = 0 ;
18144   bool result;
18145
18146   arg1 = (Dali::BaseObject *)jarg1;
18147   arg2 = (Dali::TypeInfo *)jarg2;
18148   if (!arg2) {
18149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18150     return 0;
18151   }
18152   {
18153     try {
18154       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18155     } catch (std::out_of_range& e) {
18156       {
18157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18158       };
18159     } catch (std::exception& e) {
18160       {
18161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18162       };
18163     } catch (Dali::DaliException e) {
18164       {
18165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18166       };
18167     } catch (...) {
18168       {
18169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18170       };
18171     }
18172   }
18173
18174   jresult = result;
18175   return jresult;
18176 }
18177
18178
18179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18180   unsigned int jresult ;
18181   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18182   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18183   std::string *arg3 = 0 ;
18184   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18185   bool result;
18186
18187   arg1 = (Dali::BaseObject *)jarg1;
18188   arg2 = (ConnectionTrackerInterface *)jarg2;
18189   if (!jarg3) {
18190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18191     return 0;
18192   }
18193   std::string arg3_str(jarg3);
18194   arg3 = &arg3_str;
18195   arg4 = (FunctorDelegate *)jarg4;
18196   {
18197     try {
18198       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18199     } catch (std::out_of_range& e) {
18200       {
18201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18202       };
18203     } catch (std::exception& e) {
18204       {
18205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18206       };
18207     } catch (Dali::DaliException e) {
18208       {
18209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18210       };
18211     } catch (...) {
18212       {
18213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18214       };
18215     }
18216   }
18217
18218   jresult = result;
18219
18220   //argout typemap for const std::string&
18221
18222   return jresult;
18223 }
18224
18225
18226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18227   void * jresult ;
18228   Dali::BaseHandle *arg1 = 0 ;
18229   Dali::BaseObject *result = 0 ;
18230
18231   arg1 = (Dali::BaseHandle *)jarg1;
18232   if (!arg1) {
18233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18234     return 0;
18235   }
18236   {
18237     try {
18238       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18239     } catch (std::out_of_range& e) {
18240       {
18241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18242       };
18243     } catch (std::exception& e) {
18244       {
18245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18246       };
18247     } catch (Dali::DaliException e) {
18248       {
18249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18250       };
18251     } catch (...) {
18252       {
18253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18254       };
18255     }
18256   }
18257
18258   jresult = (void *)result;
18259   return jresult;
18260 }
18261
18262
18263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18264   void * jresult ;
18265   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18266   Dali::BaseHandle *result = 0 ;
18267
18268   arg1 = (Dali::BaseObject *)jarg1;
18269   {
18270     try {
18271       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18272     } catch (std::out_of_range& e) {
18273       {
18274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18275       };
18276     } catch (std::exception& e) {
18277       {
18278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18279       };
18280     } catch (Dali::DaliException e) {
18281       {
18282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18283       };
18284     } catch (...) {
18285       {
18286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18287       };
18288     }
18289   }
18290
18291   jresult = (void *)result;
18292   return jresult;
18293 }
18294
18295
18296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18297   void * jresult ;
18298   Dali::BaseHandle *result = 0 ;
18299
18300   {
18301     try {
18302       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18303     } catch (std::out_of_range& e) {
18304       {
18305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18306       };
18307     } catch (std::exception& e) {
18308       {
18309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18310       };
18311     } catch (Dali::DaliException e) {
18312       {
18313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18314       };
18315     } catch (...) {
18316       {
18317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18318       };
18319     }
18320   }
18321
18322   jresult = (void *)result;
18323   return jresult;
18324 }
18325
18326
18327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18328   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18329
18330   arg1 = (Dali::BaseHandle *)jarg1;
18331   {
18332     try {
18333       delete arg1;
18334     } catch (std::out_of_range& e) {
18335       {
18336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18337       };
18338     } catch (std::exception& e) {
18339       {
18340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18341       };
18342     } catch (Dali::DaliException e) {
18343       {
18344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18345       };
18346     } catch (...) {
18347       {
18348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18349       };
18350     }
18351   }
18352
18353 }
18354
18355
18356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18357   void * jresult ;
18358   Dali::BaseHandle *arg1 = 0 ;
18359   Dali::BaseHandle *result = 0 ;
18360
18361   arg1 = (Dali::BaseHandle *)jarg1;
18362   if (!arg1) {
18363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18364     return 0;
18365   }
18366   {
18367     try {
18368       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18369     } catch (std::out_of_range& e) {
18370       {
18371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18372       };
18373     } catch (std::exception& e) {
18374       {
18375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18376       };
18377     } catch (Dali::DaliException e) {
18378       {
18379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18380       };
18381     } catch (...) {
18382       {
18383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18384       };
18385     }
18386   }
18387
18388   jresult = (void *)result;
18389   return jresult;
18390 }
18391
18392
18393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18394   void * jresult ;
18395   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18396   Dali::BaseHandle *arg2 = 0 ;
18397   Dali::BaseHandle *result = 0 ;
18398
18399   arg1 = (Dali::BaseHandle *)jarg1;
18400   arg2 = (Dali::BaseHandle *)jarg2;
18401   if (!arg2) {
18402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18403     return 0;
18404   }
18405   {
18406     try {
18407       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18408     } catch (std::out_of_range& e) {
18409       {
18410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18411       };
18412     } catch (std::exception& e) {
18413       {
18414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18415       };
18416     } catch (Dali::DaliException e) {
18417       {
18418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18419       };
18420     } catch (...) {
18421       {
18422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18423       };
18424     }
18425   }
18426
18427   jresult = (void *)result;
18428   return jresult;
18429 }
18430
18431
18432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18433   unsigned int jresult ;
18434   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18435   std::string *arg2 = 0 ;
18436   Dali::Property::Map *arg3 = 0 ;
18437   bool result;
18438
18439   arg1 = (Dali::BaseHandle *)jarg1;
18440   if (!jarg2) {
18441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18442     return 0;
18443   }
18444   std::string arg2_str(jarg2);
18445   arg2 = &arg2_str;
18446   arg3 = (Dali::Property::Map *)jarg3;
18447   if (!arg3) {
18448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18449     return 0;
18450   }
18451   {
18452     try {
18453       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18454     } catch (std::out_of_range& e) {
18455       {
18456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18457       };
18458     } catch (std::exception& e) {
18459       {
18460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18461       };
18462     } catch (Dali::DaliException e) {
18463       {
18464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18465       };
18466     } catch (...) {
18467       {
18468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18469       };
18470     }
18471   }
18472
18473   jresult = result;
18474
18475   //argout typemap for const std::string&
18476
18477   return jresult;
18478 }
18479
18480
18481 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18482   char * jresult ;
18483   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18484   std::string *result = 0 ;
18485
18486   arg1 = (Dali::BaseHandle *)jarg1;
18487   {
18488     try {
18489       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18490     } catch (std::out_of_range& e) {
18491       {
18492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18493       };
18494     } catch (std::exception& e) {
18495       {
18496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18497       };
18498     } catch (Dali::DaliException e) {
18499       {
18500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18501       };
18502     } catch (...) {
18503       {
18504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18505       };
18506     }
18507   }
18508
18509   jresult = SWIG_csharp_string_callback(result->c_str());
18510   return jresult;
18511 }
18512
18513
18514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18515   unsigned int jresult ;
18516   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18517   Dali::TypeInfo *arg2 = 0 ;
18518   bool result;
18519
18520   arg1 = (Dali::BaseHandle *)jarg1;
18521   arg2 = (Dali::TypeInfo *)jarg2;
18522   if (!arg2) {
18523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18524     return 0;
18525   }
18526   {
18527     try {
18528       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18529     } catch (std::out_of_range& e) {
18530       {
18531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18532       };
18533     } catch (std::exception& e) {
18534       {
18535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18536       };
18537     } catch (Dali::DaliException e) {
18538       {
18539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18540       };
18541     } catch (...) {
18542       {
18543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18544       };
18545     }
18546   }
18547
18548   jresult = result;
18549   return jresult;
18550 }
18551
18552
18553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18554   void * jresult ;
18555   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18556   Dali::BaseObject *result = 0 ;
18557
18558   arg1 = (Dali::BaseHandle *)jarg1;
18559   {
18560     try {
18561       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18562     } catch (std::out_of_range& e) {
18563       {
18564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18565       };
18566     } catch (std::exception& e) {
18567       {
18568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18569       };
18570     } catch (Dali::DaliException e) {
18571       {
18572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18573       };
18574     } catch (...) {
18575       {
18576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18577       };
18578     }
18579   }
18580
18581   jresult = (void *)result;
18582   return jresult;
18583 }
18584
18585
18586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18587   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18588
18589   arg1 = (Dali::BaseHandle *)jarg1;
18590   {
18591     try {
18592       (arg1)->Reset();
18593     } catch (std::out_of_range& e) {
18594       {
18595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18596       };
18597     } catch (std::exception& e) {
18598       {
18599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18600       };
18601     } catch (Dali::DaliException e) {
18602       {
18603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18604       };
18605     } catch (...) {
18606       {
18607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18608       };
18609     }
18610   }
18611
18612 }
18613
18614
18615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18616   unsigned int jresult ;
18617   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18618   Dali::BaseHandle *arg2 = 0 ;
18619   bool result;
18620
18621   arg1 = (Dali::BaseHandle *)jarg1;
18622   arg2 = (Dali::BaseHandle *)jarg2;
18623   if (!arg2) {
18624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18625     return 0;
18626   }
18627   {
18628     try {
18629       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18630     } catch (std::out_of_range& e) {
18631       {
18632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18633       };
18634     } catch (std::exception& e) {
18635       {
18636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18637       };
18638     } catch (Dali::DaliException e) {
18639       {
18640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18641       };
18642     } catch (...) {
18643       {
18644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18645       };
18646     }
18647   }
18648
18649   jresult = result;
18650   return jresult;
18651 }
18652
18653
18654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18655   unsigned int jresult ;
18656   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18657   Dali::BaseHandle *arg2 = 0 ;
18658   bool result;
18659
18660   arg1 = (Dali::BaseHandle *)jarg1;
18661   arg2 = (Dali::BaseHandle *)jarg2;
18662   if (!arg2) {
18663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18664     return 0;
18665   }
18666   {
18667     try {
18668       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18669     } catch (std::out_of_range& e) {
18670       {
18671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18672       };
18673     } catch (std::exception& e) {
18674       {
18675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18676       };
18677     } catch (Dali::DaliException e) {
18678       {
18679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18680       };
18681     } catch (...) {
18682       {
18683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18684       };
18685     }
18686   }
18687
18688   jresult = result;
18689   return jresult;
18690 }
18691
18692
18693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18694   void * jresult ;
18695   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18696   Dali::RefObject *result = 0 ;
18697
18698   arg1 = (Dali::BaseHandle *)jarg1;
18699   {
18700     try {
18701       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18702     } catch (std::out_of_range& e) {
18703       {
18704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18705       };
18706     } catch (std::exception& e) {
18707       {
18708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18709       };
18710     } catch (Dali::DaliException e) {
18711       {
18712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18713       };
18714     } catch (...) {
18715       {
18716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18717       };
18718     }
18719   }
18720
18721   jresult = (void *)result;
18722   return jresult;
18723 }
18724
18725
18726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18727   unsigned int jresult ;
18728   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18729   bool result;
18730
18731   arg1 = (Dali::BaseHandle *)jarg1;
18732   {
18733     try {
18734       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18735     } catch (std::out_of_range& e) {
18736       {
18737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18738       };
18739     } catch (std::exception& e) {
18740       {
18741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18742       };
18743     } catch (Dali::DaliException e) {
18744       {
18745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18746       };
18747     } catch (...) {
18748       {
18749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18750       };
18751     }
18752   }
18753
18754   jresult = result;
18755   return jresult;
18756 }
18757
18758
18759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18760   unsigned int jresult ;
18761   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18762   Dali::BaseHandle *arg2 = 0 ;
18763   bool result;
18764
18765   arg1 = (Dali::BaseHandle *)jarg1;
18766   arg2 = (Dali::BaseHandle *)jarg2;
18767   if (!arg2) {
18768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18769     return 0;
18770   }
18771   {
18772     try {
18773       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18774     } catch (std::out_of_range& e) {
18775       {
18776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18777       };
18778     } catch (std::exception& e) {
18779       {
18780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18781       };
18782     } catch (Dali::DaliException e) {
18783       {
18784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18785       };
18786     } catch (...) {
18787       {
18788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18789       };
18790     }
18791   }
18792
18793   jresult = result;
18794   return jresult;
18795 }
18796
18797
18798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18799   unsigned int jresult ;
18800   Dali::BaseHandle *arg1 = 0 ;
18801   Dali::BaseHandle *arg2 = 0 ;
18802   bool result;
18803
18804   arg1 = (Dali::BaseHandle *)jarg1;
18805   if (!arg1) {
18806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18807     return 0;
18808   }
18809   arg2 = (Dali::BaseHandle *)jarg2;
18810   if (!arg2) {
18811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18812     return 0;
18813   }
18814   {
18815     try {
18816       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18817     } catch (std::out_of_range& e) {
18818       {
18819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18820       };
18821     } catch (std::exception& e) {
18822       {
18823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18824       };
18825     } catch (Dali::DaliException e) {
18826       {
18827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18828       };
18829     } catch (...) {
18830       {
18831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18832       };
18833     }
18834   }
18835
18836   jresult = result;
18837   return jresult;
18838 }
18839
18840
18841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18842   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18843
18844   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18845   {
18846     try {
18847       delete arg1;
18848     } catch (std::out_of_range& e) {
18849       {
18850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18851       };
18852     } catch (std::exception& e) {
18853       {
18854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18855       };
18856     } catch (Dali::DaliException e) {
18857       {
18858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18859       };
18860     } catch (...) {
18861       {
18862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18863       };
18864     }
18865   }
18866
18867 }
18868
18869
18870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18871   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18872   SlotObserver *arg2 = (SlotObserver *) 0 ;
18873   CallbackBase *arg3 = (CallbackBase *) 0 ;
18874
18875   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18876   arg2 = (SlotObserver *)jarg2;
18877   arg3 = (CallbackBase *)jarg3;
18878   {
18879     try {
18880       (arg1)->SignalConnected(arg2,arg3);
18881     } catch (std::out_of_range& e) {
18882       {
18883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18884       };
18885     } catch (std::exception& e) {
18886       {
18887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18888       };
18889     } catch (Dali::DaliException e) {
18890       {
18891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18892       };
18893     } catch (...) {
18894       {
18895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18896       };
18897     }
18898   }
18899
18900 }
18901
18902
18903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18904   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18905
18906   arg1 = (Dali::SignalObserver *)jarg1;
18907   {
18908     try {
18909       delete arg1;
18910     } catch (std::out_of_range& e) {
18911       {
18912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18913       };
18914     } catch (std::exception& e) {
18915       {
18916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18917       };
18918     } catch (Dali::DaliException e) {
18919       {
18920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18921       };
18922     } catch (...) {
18923       {
18924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18925       };
18926     }
18927   }
18928
18929 }
18930
18931
18932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18933   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18934   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18935   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18936
18937   arg1 = (Dali::SignalObserver *)jarg1;
18938   arg2 = (Dali::SlotObserver *)jarg2;
18939   arg3 = (Dali::CallbackBase *)jarg3;
18940   {
18941     try {
18942       (arg1)->SignalDisconnected(arg2,arg3);
18943     } catch (std::out_of_range& e) {
18944       {
18945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18946       };
18947     } catch (std::exception& e) {
18948       {
18949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18950       };
18951     } catch (Dali::DaliException e) {
18952       {
18953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18954       };
18955     } catch (...) {
18956       {
18957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18958       };
18959     }
18960   }
18961
18962 }
18963
18964
18965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18966   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18967
18968   arg1 = (Dali::SlotObserver *)jarg1;
18969   {
18970     try {
18971       delete arg1;
18972     } catch (std::out_of_range& e) {
18973       {
18974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18975       };
18976     } catch (std::exception& e) {
18977       {
18978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18979       };
18980     } catch (Dali::DaliException e) {
18981       {
18982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18983       };
18984     } catch (...) {
18985       {
18986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18987       };
18988     }
18989   }
18990
18991 }
18992
18993
18994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18995   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18996   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18997
18998   arg1 = (Dali::SlotObserver *)jarg1;
18999   arg2 = (Dali::CallbackBase *)jarg2;
19000   {
19001     try {
19002       (arg1)->SlotDisconnected(arg2);
19003     } catch (std::out_of_range& e) {
19004       {
19005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19006       };
19007     } catch (std::exception& e) {
19008       {
19009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19010       };
19011     } catch (Dali::DaliException e) {
19012       {
19013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19014       };
19015     } catch (...) {
19016       {
19017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19018       };
19019     }
19020   }
19021
19022 }
19023
19024
19025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19026   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19027
19028   arg1 = (Dali::ConnectionTracker *)jarg1;
19029   {
19030     try {
19031       delete arg1;
19032     } catch (std::out_of_range& e) {
19033       {
19034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19035       };
19036     } catch (std::exception& e) {
19037       {
19038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19039       };
19040     } catch (Dali::DaliException e) {
19041       {
19042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19043       };
19044     } catch (...) {
19045       {
19046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19047       };
19048     }
19049   }
19050
19051 }
19052
19053
19054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19055   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19056
19057   arg1 = (Dali::ConnectionTracker *)jarg1;
19058   {
19059     try {
19060       (arg1)->DisconnectAll();
19061     } catch (std::out_of_range& e) {
19062       {
19063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19064       };
19065     } catch (std::exception& e) {
19066       {
19067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19068       };
19069     } catch (Dali::DaliException e) {
19070       {
19071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19072       };
19073     } catch (...) {
19074       {
19075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19076       };
19077     }
19078   }
19079
19080 }
19081
19082
19083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19084   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19085   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19086   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19087
19088   arg1 = (Dali::ConnectionTracker *)jarg1;
19089   arg2 = (Dali::SlotObserver *)jarg2;
19090   arg3 = (Dali::CallbackBase *)jarg3;
19091   {
19092     try {
19093       (arg1)->SignalConnected(arg2,arg3);
19094     } catch (std::out_of_range& e) {
19095       {
19096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19097       };
19098     } catch (std::exception& e) {
19099       {
19100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19101       };
19102     } catch (Dali::DaliException e) {
19103       {
19104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19105       };
19106     } catch (...) {
19107       {
19108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19109       };
19110     }
19111   }
19112
19113 }
19114
19115
19116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19117   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19118   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19119   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19120
19121   arg1 = (Dali::ConnectionTracker *)jarg1;
19122   arg2 = (Dali::SlotObserver *)jarg2;
19123   arg3 = (Dali::CallbackBase *)jarg3;
19124   {
19125     try {
19126       (arg1)->SignalDisconnected(arg2,arg3);
19127     } catch (std::out_of_range& e) {
19128       {
19129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19130       };
19131     } catch (std::exception& e) {
19132       {
19133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19134       };
19135     } catch (Dali::DaliException e) {
19136       {
19137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19138       };
19139     } catch (...) {
19140       {
19141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19142       };
19143     }
19144   }
19145
19146 }
19147
19148
19149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19150   unsigned long jresult ;
19151   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19152   std::size_t result;
19153
19154   arg1 = (Dali::ConnectionTracker *)jarg1;
19155   {
19156     try {
19157       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19158     } catch (std::out_of_range& e) {
19159       {
19160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19161       };
19162     } catch (std::exception& e) {
19163       {
19164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19165       };
19166     } catch (Dali::DaliException e) {
19167       {
19168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19169       };
19170     } catch (...) {
19171       {
19172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19173       };
19174     }
19175   }
19176
19177   jresult = (unsigned long)result;
19178   return jresult;
19179 }
19180
19181
19182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19183   void * jresult ;
19184   Dali::ObjectRegistry *result = 0 ;
19185
19186   {
19187     try {
19188       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19189     } catch (std::out_of_range& e) {
19190       {
19191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19192       };
19193     } catch (std::exception& e) {
19194       {
19195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19196       };
19197     } catch (Dali::DaliException e) {
19198       {
19199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19200       };
19201     } catch (...) {
19202       {
19203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19204       };
19205     }
19206   }
19207
19208   jresult = (void *)result;
19209   return jresult;
19210 }
19211
19212
19213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19214   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19215
19216   arg1 = (Dali::ObjectRegistry *)jarg1;
19217   {
19218     try {
19219       delete arg1;
19220     } catch (std::out_of_range& e) {
19221       {
19222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19223       };
19224     } catch (std::exception& e) {
19225       {
19226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19227       };
19228     } catch (Dali::DaliException e) {
19229       {
19230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19231       };
19232     } catch (...) {
19233       {
19234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19235       };
19236     }
19237   }
19238
19239 }
19240
19241
19242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19243   void * jresult ;
19244   Dali::ObjectRegistry *arg1 = 0 ;
19245   Dali::ObjectRegistry *result = 0 ;
19246
19247   arg1 = (Dali::ObjectRegistry *)jarg1;
19248   if (!arg1) {
19249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19250     return 0;
19251   }
19252   {
19253     try {
19254       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19255     } catch (std::out_of_range& e) {
19256       {
19257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19258       };
19259     } catch (std::exception& e) {
19260       {
19261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19262       };
19263     } catch (Dali::DaliException e) {
19264       {
19265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19266       };
19267     } catch (...) {
19268       {
19269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19270       };
19271     }
19272   }
19273
19274   jresult = (void *)result;
19275   return jresult;
19276 }
19277
19278
19279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19280   void * jresult ;
19281   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19282   Dali::ObjectRegistry *arg2 = 0 ;
19283   Dali::ObjectRegistry *result = 0 ;
19284
19285   arg1 = (Dali::ObjectRegistry *)jarg1;
19286   arg2 = (Dali::ObjectRegistry *)jarg2;
19287   if (!arg2) {
19288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19289     return 0;
19290   }
19291   {
19292     try {
19293       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19294     } catch (std::out_of_range& e) {
19295       {
19296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19297       };
19298     } catch (std::exception& e) {
19299       {
19300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19301       };
19302     } catch (Dali::DaliException e) {
19303       {
19304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19305       };
19306     } catch (...) {
19307       {
19308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19309       };
19310     }
19311   }
19312
19313   jresult = (void *)result;
19314   return jresult;
19315 }
19316
19317
19318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19319   void * jresult ;
19320   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19321   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19322
19323   arg1 = (Dali::ObjectRegistry *)jarg1;
19324   {
19325     try {
19326       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19327     } catch (std::out_of_range& e) {
19328       {
19329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19330       };
19331     } catch (std::exception& e) {
19332       {
19333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19334       };
19335     } catch (Dali::DaliException e) {
19336       {
19337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19338       };
19339     } catch (...) {
19340       {
19341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19342       };
19343     }
19344   }
19345
19346   jresult = (void *)result;
19347   return jresult;
19348 }
19349
19350
19351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19352   void * jresult ;
19353   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19354   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19355
19356   arg1 = (Dali::ObjectRegistry *)jarg1;
19357   {
19358     try {
19359       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19360     } catch (std::out_of_range& e) {
19361       {
19362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19363       };
19364     } catch (std::exception& e) {
19365       {
19366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19367       };
19368     } catch (Dali::DaliException e) {
19369       {
19370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19371       };
19372     } catch (...) {
19373       {
19374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19375       };
19376     }
19377   }
19378
19379   jresult = (void *)result;
19380   return jresult;
19381 }
19382
19383
19384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19385   void * jresult ;
19386   Dali::PropertyCondition *result = 0 ;
19387
19388   {
19389     try {
19390       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19391     } catch (std::out_of_range& e) {
19392       {
19393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19394       };
19395     } catch (std::exception& e) {
19396       {
19397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19398       };
19399     } catch (Dali::DaliException e) {
19400       {
19401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19402       };
19403     } catch (...) {
19404       {
19405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19406       };
19407     }
19408   }
19409
19410   jresult = (void *)result;
19411   return jresult;
19412 }
19413
19414
19415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19416   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19417
19418   arg1 = (Dali::PropertyCondition *)jarg1;
19419   {
19420     try {
19421       delete arg1;
19422     } catch (std::out_of_range& e) {
19423       {
19424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19425       };
19426     } catch (std::exception& e) {
19427       {
19428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19429       };
19430     } catch (Dali::DaliException e) {
19431       {
19432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19433       };
19434     } catch (...) {
19435       {
19436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19437       };
19438     }
19439   }
19440
19441 }
19442
19443
19444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19445   void * jresult ;
19446   Dali::PropertyCondition *arg1 = 0 ;
19447   Dali::PropertyCondition *result = 0 ;
19448
19449   arg1 = (Dali::PropertyCondition *)jarg1;
19450   if (!arg1) {
19451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19452     return 0;
19453   }
19454   {
19455     try {
19456       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19457     } catch (std::out_of_range& e) {
19458       {
19459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19460       };
19461     } catch (std::exception& e) {
19462       {
19463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19464       };
19465     } catch (Dali::DaliException e) {
19466       {
19467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19468       };
19469     } catch (...) {
19470       {
19471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19472       };
19473     }
19474   }
19475
19476   jresult = (void *)result;
19477   return jresult;
19478 }
19479
19480
19481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19482   void * jresult ;
19483   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19484   Dali::PropertyCondition *arg2 = 0 ;
19485   Dali::PropertyCondition *result = 0 ;
19486
19487   arg1 = (Dali::PropertyCondition *)jarg1;
19488   arg2 = (Dali::PropertyCondition *)jarg2;
19489   if (!arg2) {
19490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19491     return 0;
19492   }
19493   {
19494     try {
19495       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19496     } catch (std::out_of_range& e) {
19497       {
19498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19499       };
19500     } catch (std::exception& e) {
19501       {
19502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19503       };
19504     } catch (Dali::DaliException e) {
19505       {
19506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19507       };
19508     } catch (...) {
19509       {
19510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19511       };
19512     }
19513   }
19514
19515   jresult = (void *)result;
19516   return jresult;
19517 }
19518
19519
19520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19521   unsigned long jresult ;
19522   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19523   std::size_t result;
19524
19525   arg1 = (Dali::PropertyCondition *)jarg1;
19526   {
19527     try {
19528       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19529     } catch (std::out_of_range& e) {
19530       {
19531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19532       };
19533     } catch (std::exception& e) {
19534       {
19535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19536       };
19537     } catch (...) {
19538       {
19539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19540       };
19541     }
19542   }
19543   jresult = (unsigned long)result;
19544   return jresult;
19545 }
19546
19547
19548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19549   float jresult ;
19550   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19551   std::size_t arg2 ;
19552   float result;
19553
19554   arg1 = (Dali::PropertyCondition *)jarg1;
19555   arg2 = (std::size_t)jarg2;
19556   {
19557     try {
19558       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19559     } catch (std::out_of_range& e) {
19560       {
19561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19562       };
19563     } catch (std::exception& e) {
19564       {
19565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19566       };
19567     } catch (...) {
19568       {
19569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19570       };
19571     }
19572   }
19573   jresult = result;
19574   return jresult;
19575 }
19576
19577
19578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19579   void * jresult ;
19580   float arg1 ;
19581   Dali::PropertyCondition result;
19582
19583   arg1 = (float)jarg1;
19584   {
19585     try {
19586       result = Dali::LessThanCondition(arg1);
19587     } catch (std::out_of_range& e) {
19588       {
19589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19590       };
19591     } catch (std::exception& e) {
19592       {
19593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19594       };
19595     } catch (Dali::DaliException e) {
19596       {
19597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19598       };
19599     } catch (...) {
19600       {
19601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19602       };
19603     }
19604   }
19605
19606   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19607   return jresult;
19608 }
19609
19610
19611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19612   void * jresult ;
19613   float arg1 ;
19614   Dali::PropertyCondition result;
19615
19616   arg1 = (float)jarg1;
19617   {
19618     try {
19619       result = Dali::GreaterThanCondition(arg1);
19620     } catch (std::out_of_range& e) {
19621       {
19622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19623       };
19624     } catch (std::exception& e) {
19625       {
19626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19627       };
19628     } catch (Dali::DaliException e) {
19629       {
19630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19631       };
19632     } catch (...) {
19633       {
19634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19635       };
19636     }
19637   }
19638
19639   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19640   return jresult;
19641 }
19642
19643
19644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19645   void * jresult ;
19646   float arg1 ;
19647   float arg2 ;
19648   Dali::PropertyCondition result;
19649
19650   arg1 = (float)jarg1;
19651   arg2 = (float)jarg2;
19652   {
19653     try {
19654       result = Dali::InsideCondition(arg1,arg2);
19655     } catch (std::out_of_range& e) {
19656       {
19657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19658       };
19659     } catch (std::exception& e) {
19660       {
19661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19662       };
19663     } catch (Dali::DaliException e) {
19664       {
19665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19666       };
19667     } catch (...) {
19668       {
19669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19670       };
19671     }
19672   }
19673
19674   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19675   return jresult;
19676 }
19677
19678
19679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19680   void * jresult ;
19681   float arg1 ;
19682   float arg2 ;
19683   Dali::PropertyCondition result;
19684
19685   arg1 = (float)jarg1;
19686   arg2 = (float)jarg2;
19687   {
19688     try {
19689       result = Dali::OutsideCondition(arg1,arg2);
19690     } catch (std::out_of_range& e) {
19691       {
19692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19693       };
19694     } catch (std::exception& e) {
19695       {
19696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19697       };
19698     } catch (Dali::DaliException e) {
19699       {
19700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19701       };
19702     } catch (...) {
19703       {
19704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19705       };
19706     }
19707   }
19708
19709   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19710   return jresult;
19711 }
19712
19713
19714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19715   void * jresult ;
19716   float arg1 ;
19717   float arg2 ;
19718   Dali::PropertyCondition result;
19719
19720   arg1 = (float)jarg1;
19721   arg2 = (float)jarg2;
19722   {
19723     try {
19724       result = Dali::StepCondition(arg1,arg2);
19725     } catch (std::out_of_range& e) {
19726       {
19727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19728       };
19729     } catch (std::exception& e) {
19730       {
19731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19732       };
19733     } catch (Dali::DaliException e) {
19734       {
19735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19736       };
19737     } catch (...) {
19738       {
19739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19740       };
19741     }
19742   }
19743
19744   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19745   return jresult;
19746 }
19747
19748
19749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19750   void * jresult ;
19751   float arg1 ;
19752   Dali::PropertyCondition result;
19753
19754   arg1 = (float)jarg1;
19755   {
19756     try {
19757       result = Dali::StepCondition(arg1);
19758     } catch (std::out_of_range& e) {
19759       {
19760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19761       };
19762     } catch (std::exception& e) {
19763       {
19764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19765       };
19766     } catch (Dali::DaliException e) {
19767       {
19768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19769       };
19770     } catch (...) {
19771       {
19772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19773       };
19774     }
19775   }
19776
19777   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19778   return jresult;
19779 }
19780
19781
19782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19783   void * jresult ;
19784   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19785   Dali::PropertyCondition result;
19786
19787   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19788   if (!arg1) {
19789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19790     return 0;
19791   }
19792   {
19793     try {
19794       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19795     } catch (std::out_of_range& e) {
19796       {
19797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19798       };
19799     } catch (std::exception& e) {
19800       {
19801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19802       };
19803     } catch (Dali::DaliException e) {
19804       {
19805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19806       };
19807     } catch (...) {
19808       {
19809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19810       };
19811     }
19812   }
19813
19814   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19815   return jresult;
19816 }
19817
19818
19819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19820   void * jresult ;
19821   Dali::PropertyNotification *result = 0 ;
19822
19823   {
19824     try {
19825       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19826     } catch (std::out_of_range& e) {
19827       {
19828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19829       };
19830     } catch (std::exception& e) {
19831       {
19832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19833       };
19834     } catch (Dali::DaliException e) {
19835       {
19836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19837       };
19838     } catch (...) {
19839       {
19840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19841       };
19842     }
19843   }
19844
19845   jresult = (void *)result;
19846   return jresult;
19847 }
19848
19849
19850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19851   void * jresult ;
19852   Dali::BaseHandle arg1 ;
19853   Dali::BaseHandle *argp1 ;
19854   Dali::PropertyNotification result;
19855
19856   argp1 = (Dali::BaseHandle *)jarg1;
19857   if (!argp1) {
19858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19859     return 0;
19860   }
19861   arg1 = *argp1;
19862   {
19863     try {
19864       result = Dali::PropertyNotification::DownCast(arg1);
19865     } catch (std::out_of_range& e) {
19866       {
19867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19868       };
19869     } catch (std::exception& e) {
19870       {
19871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (Dali::DaliException e) {
19874       {
19875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19876       };
19877     } catch (...) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19880       };
19881     }
19882   }
19883
19884   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19885   return jresult;
19886 }
19887
19888
19889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19890   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19891
19892   arg1 = (Dali::PropertyNotification *)jarg1;
19893   {
19894     try {
19895       delete arg1;
19896     } catch (std::out_of_range& e) {
19897       {
19898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19899       };
19900     } catch (std::exception& e) {
19901       {
19902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19903       };
19904     } catch (Dali::DaliException e) {
19905       {
19906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19907       };
19908     } catch (...) {
19909       {
19910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19911       };
19912     }
19913   }
19914
19915 }
19916
19917
19918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19919   void * jresult ;
19920   Dali::PropertyNotification *arg1 = 0 ;
19921   Dali::PropertyNotification *result = 0 ;
19922
19923   arg1 = (Dali::PropertyNotification *)jarg1;
19924   if (!arg1) {
19925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19926     return 0;
19927   }
19928   {
19929     try {
19930       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19931     } catch (std::out_of_range& e) {
19932       {
19933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19934       };
19935     } catch (std::exception& e) {
19936       {
19937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19938       };
19939     } catch (Dali::DaliException e) {
19940       {
19941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19942       };
19943     } catch (...) {
19944       {
19945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19946       };
19947     }
19948   }
19949
19950   jresult = (void *)result;
19951   return jresult;
19952 }
19953
19954
19955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19956   void * jresult ;
19957   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19958   Dali::PropertyNotification *arg2 = 0 ;
19959   Dali::PropertyNotification *result = 0 ;
19960
19961   arg1 = (Dali::PropertyNotification *)jarg1;
19962   arg2 = (Dali::PropertyNotification *)jarg2;
19963   if (!arg2) {
19964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19965     return 0;
19966   }
19967   {
19968     try {
19969       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19970     } catch (std::out_of_range& e) {
19971       {
19972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19973       };
19974     } catch (std::exception& e) {
19975       {
19976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19977       };
19978     } catch (Dali::DaliException e) {
19979       {
19980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19981       };
19982     } catch (...) {
19983       {
19984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19985       };
19986     }
19987   }
19988
19989   jresult = (void *)result;
19990   return jresult;
19991 }
19992
19993
19994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19995   void * jresult ;
19996   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19997   Dali::PropertyCondition result;
19998
19999   arg1 = (Dali::PropertyNotification *)jarg1;
20000   {
20001     try {
20002       result = (arg1)->GetCondition();
20003     } catch (std::out_of_range& e) {
20004       {
20005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20006       };
20007     } catch (std::exception& e) {
20008       {
20009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20010       };
20011     } catch (Dali::DaliException e) {
20012       {
20013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20014       };
20015     } catch (...) {
20016       {
20017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20018       };
20019     }
20020   }
20021
20022   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20023   return jresult;
20024 }
20025
20026
20027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20028   void * jresult ;
20029   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20030   Dali::Handle result;
20031
20032   arg1 = (Dali::PropertyNotification *)jarg1;
20033   {
20034     try {
20035       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20036     } catch (std::out_of_range& e) {
20037       {
20038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20039       };
20040     } catch (std::exception& e) {
20041       {
20042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20043       };
20044     } catch (Dali::DaliException e) {
20045       {
20046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20047       };
20048     } catch (...) {
20049       {
20050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20051       };
20052     }
20053   }
20054
20055   jresult = new Dali::Handle((const Dali::Handle &)result);
20056   return jresult;
20057 }
20058
20059
20060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20061   int jresult ;
20062   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20063   Dali::Property::Index result;
20064
20065   arg1 = (Dali::PropertyNotification *)jarg1;
20066   {
20067     try {
20068       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20069     } catch (std::out_of_range& e) {
20070       {
20071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20072       };
20073     } catch (std::exception& e) {
20074       {
20075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20076       };
20077     } catch (Dali::DaliException e) {
20078       {
20079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20080       };
20081     } catch (...) {
20082       {
20083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20084       };
20085     }
20086   }
20087
20088   jresult = result;
20089   return jresult;
20090 }
20091
20092
20093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20094   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20095   Dali::PropertyNotification::NotifyMode arg2 ;
20096
20097   arg1 = (Dali::PropertyNotification *)jarg1;
20098   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20099   {
20100     try {
20101       (arg1)->SetNotifyMode(arg2);
20102     } catch (std::out_of_range& e) {
20103       {
20104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20105       };
20106     } catch (std::exception& e) {
20107       {
20108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20109       };
20110     } catch (Dali::DaliException e) {
20111       {
20112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20113       };
20114     } catch (...) {
20115       {
20116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20117       };
20118     }
20119   }
20120
20121 }
20122
20123
20124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20125   int jresult ;
20126   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20127   Dali::PropertyNotification::NotifyMode result;
20128
20129   arg1 = (Dali::PropertyNotification *)jarg1;
20130   {
20131     try {
20132       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20133     } catch (std::out_of_range& e) {
20134       {
20135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20136       };
20137     } catch (std::exception& e) {
20138       {
20139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20140       };
20141     } catch (Dali::DaliException e) {
20142       {
20143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20144       };
20145     } catch (...) {
20146       {
20147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20148       };
20149     }
20150   }
20151
20152   jresult = (int)result;
20153   return jresult;
20154 }
20155
20156
20157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20158   unsigned int jresult ;
20159   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20160   bool result;
20161
20162   arg1 = (Dali::PropertyNotification *)jarg1;
20163   {
20164     try {
20165       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20166     } catch (std::out_of_range& e) {
20167       {
20168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20169       };
20170     } catch (std::exception& e) {
20171       {
20172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20173       };
20174     } catch (Dali::DaliException e) {
20175       {
20176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20177       };
20178     } catch (...) {
20179       {
20180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20181       };
20182     }
20183   }
20184
20185   jresult = result;
20186   return jresult;
20187 }
20188
20189
20190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20191   void * jresult ;
20192   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20193   Dali::PropertyNotifySignalType *result = 0 ;
20194
20195   arg1 = (Dali::PropertyNotification *)jarg1;
20196   {
20197     try {
20198       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20199     } catch (std::out_of_range& e) {
20200       {
20201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20202       };
20203     } catch (std::exception& e) {
20204       {
20205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20206       };
20207     } catch (Dali::DaliException e) {
20208       {
20209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20210       };
20211     } catch (...) {
20212       {
20213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20214       };
20215     }
20216   }
20217
20218   jresult = (void *)result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20224   void * jresult ;
20225   Dali::Handle *result = 0 ;
20226
20227   {
20228     try {
20229       result = (Dali::Handle *)new Dali::Handle();
20230     } catch (std::out_of_range& e) {
20231       {
20232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20233       };
20234     } catch (std::exception& e) {
20235       {
20236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20237       };
20238     } catch (Dali::DaliException e) {
20239       {
20240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20241       };
20242     } catch (...) {
20243       {
20244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20245       };
20246     }
20247   }
20248
20249   jresult = (void *)result;
20250   return jresult;
20251 }
20252
20253
20254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20255   void * jresult ;
20256   Dali::Handle result;
20257
20258   {
20259     try {
20260       result = Dali::Handle::New();
20261     } catch (std::out_of_range& e) {
20262       {
20263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20264       };
20265     } catch (std::exception& e) {
20266       {
20267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20268       };
20269     } catch (Dali::DaliException e) {
20270       {
20271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20272       };
20273     } catch (...) {
20274       {
20275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20276       };
20277     }
20278   }
20279
20280   jresult = new Dali::Handle((const Dali::Handle &)result);
20281   return jresult;
20282 }
20283
20284
20285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20286   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20287
20288   arg1 = (Dali::Handle *)jarg1;
20289   {
20290     try {
20291       delete arg1;
20292     } catch (std::out_of_range& e) {
20293       {
20294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20295       };
20296     } catch (std::exception& e) {
20297       {
20298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20299       };
20300     } catch (Dali::DaliException e) {
20301       {
20302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20303       };
20304     } catch (...) {
20305       {
20306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20307       };
20308     }
20309   }
20310
20311 }
20312
20313
20314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20315   void * jresult ;
20316   Dali::Handle *arg1 = 0 ;
20317   Dali::Handle *result = 0 ;
20318
20319   arg1 = (Dali::Handle *)jarg1;
20320   if (!arg1) {
20321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20322     return 0;
20323   }
20324   {
20325     try {
20326       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20327     } catch (std::out_of_range& e) {
20328       {
20329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20330       };
20331     } catch (std::exception& e) {
20332       {
20333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20334       };
20335     } catch (Dali::DaliException e) {
20336       {
20337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20338       };
20339     } catch (...) {
20340       {
20341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20342       };
20343     }
20344   }
20345
20346   jresult = (void *)result;
20347   return jresult;
20348 }
20349
20350
20351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20352   void * jresult ;
20353   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20354   Dali::Handle *arg2 = 0 ;
20355   Dali::Handle *result = 0 ;
20356
20357   arg1 = (Dali::Handle *)jarg1;
20358   arg2 = (Dali::Handle *)jarg2;
20359   if (!arg2) {
20360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20361     return 0;
20362   }
20363   {
20364     try {
20365       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20366     } catch (std::out_of_range& e) {
20367       {
20368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20369       };
20370     } catch (std::exception& e) {
20371       {
20372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20373       };
20374     } catch (Dali::DaliException e) {
20375       {
20376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20377       };
20378     } catch (...) {
20379       {
20380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20381       };
20382     }
20383   }
20384
20385   jresult = (void *)result;
20386   return jresult;
20387 }
20388
20389
20390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20391   void * jresult ;
20392   Dali::BaseHandle arg1 ;
20393   Dali::BaseHandle *argp1 ;
20394   Dali::Handle result;
20395
20396   argp1 = (Dali::BaseHandle *)jarg1;
20397   if (!argp1) {
20398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20399     return 0;
20400   }
20401   arg1 = *argp1;
20402   {
20403     try {
20404       result = Dali::Handle::DownCast(arg1);
20405     } catch (std::out_of_range& e) {
20406       {
20407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20408       };
20409     } catch (std::exception& e) {
20410       {
20411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20412       };
20413     } catch (Dali::DaliException e) {
20414       {
20415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20416       };
20417     } catch (...) {
20418       {
20419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20420       };
20421     }
20422   }
20423
20424   jresult = new Dali::Handle((const Dali::Handle &)result);
20425   return jresult;
20426 }
20427
20428
20429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20430   unsigned int jresult ;
20431   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20432   Dali::Handle::Capability arg2 ;
20433   bool result;
20434
20435   arg1 = (Dali::Handle *)jarg1;
20436   arg2 = (Dali::Handle::Capability)jarg2;
20437   {
20438     try {
20439       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20440     } catch (std::out_of_range& e) {
20441       {
20442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20443       };
20444     } catch (std::exception& e) {
20445       {
20446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20447       };
20448     } catch (Dali::DaliException e) {
20449       {
20450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20451       };
20452     } catch (...) {
20453       {
20454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20455       };
20456     }
20457   }
20458
20459   jresult = result;
20460   return jresult;
20461 }
20462
20463
20464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20465   unsigned int jresult ;
20466   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20467   unsigned int result;
20468
20469   arg1 = (Dali::Handle *)jarg1;
20470   {
20471     try {
20472       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20473     } catch (std::out_of_range& e) {
20474       {
20475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20476       };
20477     } catch (std::exception& e) {
20478       {
20479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20480       };
20481     } catch (Dali::DaliException e) {
20482       {
20483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20484       };
20485     } catch (...) {
20486       {
20487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20488       };
20489     }
20490   }
20491
20492   jresult = result;
20493   return jresult;
20494 }
20495
20496
20497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20498   char * jresult ;
20499   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20500   Dali::Property::Index arg2 ;
20501   std::string result;
20502
20503   arg1 = (Dali::Handle *)jarg1;
20504   arg2 = (Dali::Property::Index)jarg2;
20505   {
20506     try {
20507       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20508     } catch (std::out_of_range& e) {
20509       {
20510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20511       };
20512     } catch (std::exception& e) {
20513       {
20514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20515       };
20516     } catch (Dali::DaliException e) {
20517       {
20518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20519       };
20520     } catch (...) {
20521       {
20522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20523       };
20524     }
20525   }
20526
20527   jresult = SWIG_csharp_string_callback((&result)->c_str());
20528   return jresult;
20529 }
20530
20531
20532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20533   int jresult ;
20534   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20535   std::string *arg2 = 0 ;
20536   Dali::Property::Index result;
20537
20538   arg1 = (Dali::Handle *)jarg1;
20539   if (!jarg2) {
20540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20541     return 0;
20542   }
20543   std::string arg2_str(jarg2);
20544   arg2 = &arg2_str;
20545   {
20546     try {
20547       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20548     } catch (std::out_of_range& e) {
20549       {
20550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20551       };
20552     } catch (std::exception& e) {
20553       {
20554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20555       };
20556     } catch (Dali::DaliException e) {
20557       {
20558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20559       };
20560     } catch (...) {
20561       {
20562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20563       };
20564     }
20565   }
20566
20567   jresult = result;
20568
20569   //argout typemap for const std::string&
20570
20571   return jresult;
20572 }
20573
20574
20575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20576   unsigned int jresult ;
20577   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20578   Dali::Property::Index arg2 ;
20579   bool result;
20580
20581   arg1 = (Dali::Handle *)jarg1;
20582   arg2 = (Dali::Property::Index)jarg2;
20583   {
20584     try {
20585       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20586     } catch (std::out_of_range& e) {
20587       {
20588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20589       };
20590     } catch (std::exception& e) {
20591       {
20592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20593       };
20594     } catch (Dali::DaliException e) {
20595       {
20596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20597       };
20598     } catch (...) {
20599       {
20600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20601       };
20602     }
20603   }
20604
20605   jresult = result;
20606   return jresult;
20607 }
20608
20609
20610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20611   unsigned int jresult ;
20612   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20613   Dali::Property::Index arg2 ;
20614   bool result;
20615
20616   arg1 = (Dali::Handle *)jarg1;
20617   arg2 = (Dali::Property::Index)jarg2;
20618   {
20619     try {
20620       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20621     } catch (std::out_of_range& e) {
20622       {
20623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20624       };
20625     } catch (std::exception& e) {
20626       {
20627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20628       };
20629     } catch (Dali::DaliException e) {
20630       {
20631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20632       };
20633     } catch (...) {
20634       {
20635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20636       };
20637     }
20638   }
20639
20640   jresult = result;
20641   return jresult;
20642 }
20643
20644
20645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20646   unsigned int jresult ;
20647   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20648   Dali::Property::Index arg2 ;
20649   bool result;
20650
20651   arg1 = (Dali::Handle *)jarg1;
20652   arg2 = (Dali::Property::Index)jarg2;
20653   {
20654     try {
20655       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20656     } catch (std::out_of_range& e) {
20657       {
20658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20659       };
20660     } catch (std::exception& e) {
20661       {
20662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20663       };
20664     } catch (Dali::DaliException e) {
20665       {
20666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20667       };
20668     } catch (...) {
20669       {
20670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20671       };
20672     }
20673   }
20674
20675   jresult = result;
20676   return jresult;
20677 }
20678
20679
20680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20681   int jresult ;
20682   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20683   Dali::Property::Index arg2 ;
20684   Dali::Property::Type result;
20685
20686   arg1 = (Dali::Handle *)jarg1;
20687   arg2 = (Dali::Property::Index)jarg2;
20688   {
20689     try {
20690       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20691     } catch (std::out_of_range& e) {
20692       {
20693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20694       };
20695     } catch (std::exception& e) {
20696       {
20697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20698       };
20699     } catch (Dali::DaliException e) {
20700       {
20701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20702       };
20703     } catch (...) {
20704       {
20705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20706       };
20707     }
20708   }
20709
20710   jresult = (int)result;
20711   return jresult;
20712 }
20713
20714
20715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20716   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20717   Dali::Property::Index arg2 ;
20718   Dali::Property::Value *arg3 = 0 ;
20719
20720   arg1 = (Dali::Handle *)jarg1;
20721   arg2 = (Dali::Property::Index)jarg2;
20722   arg3 = (Dali::Property::Value *)jarg3;
20723   if (!arg3) {
20724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20725     return ;
20726   }
20727   {
20728     try {
20729       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20730     } catch (std::out_of_range& e) {
20731       {
20732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20733       };
20734     } catch (std::exception& e) {
20735       {
20736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20737       };
20738     } catch (Dali::DaliException e) {
20739       {
20740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20741       };
20742     } catch (...) {
20743       {
20744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20745       };
20746     }
20747   }
20748
20749 }
20750
20751
20752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20753   int jresult ;
20754   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20755   std::string *arg2 = 0 ;
20756   Dali::Property::Value *arg3 = 0 ;
20757   Dali::Property::Index result;
20758
20759   arg1 = (Dali::Handle *)jarg1;
20760   if (!jarg2) {
20761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20762     return 0;
20763   }
20764   std::string arg2_str(jarg2);
20765   arg2 = &arg2_str;
20766   arg3 = (Dali::Property::Value *)jarg3;
20767   if (!arg3) {
20768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20769     return 0;
20770   }
20771   {
20772     try {
20773       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20774     } catch (std::out_of_range& e) {
20775       {
20776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20777       };
20778     } catch (std::exception& e) {
20779       {
20780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20781       };
20782     } catch (Dali::DaliException e) {
20783       {
20784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20785       };
20786     } catch (...) {
20787       {
20788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20789       };
20790     }
20791   }
20792
20793   jresult = result;
20794
20795   //argout typemap for const std::string&
20796
20797   return jresult;
20798 }
20799
20800
20801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20802   int jresult ;
20803   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20804   std::string *arg2 = 0 ;
20805   Dali::Property::Value *arg3 = 0 ;
20806   Dali::Property::AccessMode arg4 ;
20807   Dali::Property::Index result;
20808
20809   arg1 = (Dali::Handle *)jarg1;
20810   if (!jarg2) {
20811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20812     return 0;
20813   }
20814   std::string arg2_str(jarg2);
20815   arg2 = &arg2_str;
20816   arg3 = (Dali::Property::Value *)jarg3;
20817   if (!arg3) {
20818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20819     return 0;
20820   }
20821   arg4 = (Dali::Property::AccessMode)jarg4;
20822   {
20823     try {
20824       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20825     } catch (std::out_of_range& e) {
20826       {
20827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20828       };
20829     } catch (std::exception& e) {
20830       {
20831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20832       };
20833     } catch (Dali::DaliException e) {
20834       {
20835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20836       };
20837     } catch (...) {
20838       {
20839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20840       };
20841     }
20842   }
20843
20844   jresult = result;
20845
20846   //argout typemap for const std::string&
20847
20848   return jresult;
20849 }
20850
20851
20852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20853   void * jresult ;
20854   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20855   Dali::Property::Index arg2 ;
20856   Dali::Property::Value result;
20857
20858   arg1 = (Dali::Handle *)jarg1;
20859   arg2 = (Dali::Property::Index)jarg2;
20860   {
20861     try {
20862       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20863     } catch (std::out_of_range& e) {
20864       {
20865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20866       };
20867     } catch (std::exception& e) {
20868       {
20869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20870       };
20871     } catch (Dali::DaliException e) {
20872       {
20873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20874       };
20875     } catch (...) {
20876       {
20877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20878       };
20879     }
20880   }
20881
20882   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20883   return jresult;
20884 }
20885
20886
20887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20888   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20889   Dali::Property::IndexContainer *arg2 = 0 ;
20890
20891   arg1 = (Dali::Handle *)jarg1;
20892   arg2 = (Dali::Property::IndexContainer *)jarg2;
20893   if (!arg2) {
20894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20895     return ;
20896   }
20897   {
20898     try {
20899       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20900     } catch (std::out_of_range& e) {
20901       {
20902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20903       };
20904     } catch (std::exception& e) {
20905       {
20906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20907       };
20908     } catch (Dali::DaliException e) {
20909       {
20910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20911       };
20912     } catch (...) {
20913       {
20914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20915       };
20916     }
20917   }
20918
20919 }
20920
20921
20922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20923   void * jresult ;
20924   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20925   Dali::Property::Index arg2 ;
20926   Dali::PropertyCondition *arg3 = 0 ;
20927   Dali::PropertyNotification result;
20928
20929   arg1 = (Dali::Handle *)jarg1;
20930   arg2 = (Dali::Property::Index)jarg2;
20931   arg3 = (Dali::PropertyCondition *)jarg3;
20932   if (!arg3) {
20933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20934     return 0;
20935   }
20936   {
20937     try {
20938       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20939     } catch (std::out_of_range& e) {
20940       {
20941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20942       };
20943     } catch (std::exception& e) {
20944       {
20945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20946       };
20947     } catch (Dali::DaliException e) {
20948       {
20949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20950       };
20951     } catch (...) {
20952       {
20953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20954       };
20955     }
20956   }
20957
20958   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20959   return jresult;
20960 }
20961
20962
20963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20964   void * jresult ;
20965   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20966   Dali::Property::Index arg2 ;
20967   int arg3 ;
20968   Dali::PropertyCondition *arg4 = 0 ;
20969   Dali::PropertyNotification result;
20970
20971   arg1 = (Dali::Handle *)jarg1;
20972   arg2 = (Dali::Property::Index)jarg2;
20973   arg3 = (int)jarg3;
20974   arg4 = (Dali::PropertyCondition *)jarg4;
20975   if (!arg4) {
20976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20977     return 0;
20978   }
20979   {
20980     try {
20981       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
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 (Dali::DaliException e) {
20991       {
20992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20993       };
20994     } catch (...) {
20995       {
20996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20997       };
20998     }
20999   }
21000
21001   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21002   return jresult;
21003 }
21004
21005
21006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21007   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21008   Dali::PropertyNotification arg2 ;
21009   Dali::PropertyNotification *argp2 ;
21010
21011   arg1 = (Dali::Handle *)jarg1;
21012   argp2 = (Dali::PropertyNotification *)jarg2;
21013   if (!argp2) {
21014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21015     return ;
21016   }
21017   arg2 = *argp2;
21018   {
21019     try {
21020       (arg1)->RemovePropertyNotification(arg2);
21021     } catch (std::out_of_range& e) {
21022       {
21023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21024       };
21025     } catch (std::exception& e) {
21026       {
21027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21028       };
21029     } catch (Dali::DaliException e) {
21030       {
21031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21032       };
21033     } catch (...) {
21034       {
21035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21036       };
21037     }
21038   }
21039
21040 }
21041
21042
21043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21044   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21045
21046   arg1 = (Dali::Handle *)jarg1;
21047   {
21048     try {
21049       (arg1)->RemovePropertyNotifications();
21050     } catch (std::out_of_range& e) {
21051       {
21052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21053       };
21054     } catch (std::exception& e) {
21055       {
21056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21057       };
21058     } catch (Dali::DaliException e) {
21059       {
21060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21061       };
21062     } catch (...) {
21063       {
21064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21065       };
21066     }
21067   }
21068
21069 }
21070
21071
21072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21073   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21074
21075   arg1 = (Dali::Handle *)jarg1;
21076   {
21077     try {
21078       (arg1)->RemoveConstraints();
21079     } catch (std::out_of_range& e) {
21080       {
21081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21082       };
21083     } catch (std::exception& e) {
21084       {
21085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21086       };
21087     } catch (Dali::DaliException e) {
21088       {
21089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21090       };
21091     } catch (...) {
21092       {
21093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21094       };
21095     }
21096   }
21097
21098 }
21099
21100
21101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21102   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21103   unsigned int arg2 ;
21104
21105   arg1 = (Dali::Handle *)jarg1;
21106   arg2 = (unsigned int)jarg2;
21107   {
21108     try {
21109       (arg1)->RemoveConstraints(arg2);
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 (Dali::DaliException e) {
21119       {
21120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21121       };
21122     } catch (...) {
21123       {
21124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21125       };
21126     }
21127   }
21128
21129 }
21130
21131
21132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21133   int jresult ;
21134   Dali::Property::Index result;
21135
21136   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21137   jresult = result;
21138   return jresult;
21139 }
21140
21141
21142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21143   void * jresult ;
21144   Dali::Handle result;
21145
21146   {
21147     try {
21148       result = Dali::WeightObject::New();
21149     } catch (std::out_of_range& e) {
21150       {
21151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21152       };
21153     } catch (std::exception& e) {
21154       {
21155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21156       };
21157     } catch (Dali::DaliException e) {
21158       {
21159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21160       };
21161     } catch (...) {
21162       {
21163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21164       };
21165     }
21166   }
21167
21168   jresult = new Dali::Handle((const Dali::Handle &)result);
21169   return jresult;
21170 }
21171
21172
21173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21174   void * jresult ;
21175   Dali::TypeInfo *result = 0 ;
21176
21177   {
21178     try {
21179       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21180     } catch (std::out_of_range& e) {
21181       {
21182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21183       };
21184     } catch (std::exception& e) {
21185       {
21186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21187       };
21188     } catch (Dali::DaliException e) {
21189       {
21190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21191       };
21192     } catch (...) {
21193       {
21194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21195       };
21196     }
21197   }
21198
21199   jresult = (void *)result;
21200   return jresult;
21201 }
21202
21203
21204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21205   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21206
21207   arg1 = (Dali::TypeInfo *)jarg1;
21208   {
21209     try {
21210       delete arg1;
21211     } catch (std::out_of_range& e) {
21212       {
21213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21214       };
21215     } catch (std::exception& e) {
21216       {
21217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21218       };
21219     } catch (Dali::DaliException e) {
21220       {
21221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21222       };
21223     } catch (...) {
21224       {
21225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21226       };
21227     }
21228   }
21229
21230 }
21231
21232
21233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21234   void * jresult ;
21235   Dali::TypeInfo *arg1 = 0 ;
21236   Dali::TypeInfo *result = 0 ;
21237
21238   arg1 = (Dali::TypeInfo *)jarg1;
21239   if (!arg1) {
21240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21241     return 0;
21242   }
21243   {
21244     try {
21245       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21246     } catch (std::out_of_range& e) {
21247       {
21248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21249       };
21250     } catch (std::exception& e) {
21251       {
21252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21253       };
21254     } catch (Dali::DaliException e) {
21255       {
21256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21257       };
21258     } catch (...) {
21259       {
21260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21261       };
21262     }
21263   }
21264
21265   jresult = (void *)result;
21266   return jresult;
21267 }
21268
21269
21270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21271   void * jresult ;
21272   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21273   Dali::TypeInfo *arg2 = 0 ;
21274   Dali::TypeInfo *result = 0 ;
21275
21276   arg1 = (Dali::TypeInfo *)jarg1;
21277   arg2 = (Dali::TypeInfo *)jarg2;
21278   if (!arg2) {
21279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21280     return 0;
21281   }
21282   {
21283     try {
21284       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21285     } catch (std::out_of_range& e) {
21286       {
21287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21288       };
21289     } catch (std::exception& e) {
21290       {
21291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21292       };
21293     } catch (Dali::DaliException e) {
21294       {
21295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21296       };
21297     } catch (...) {
21298       {
21299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21300       };
21301     }
21302   }
21303
21304   jresult = (void *)result;
21305   return jresult;
21306 }
21307
21308
21309 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21310   char * jresult ;
21311   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21312   std::string *result = 0 ;
21313
21314   arg1 = (Dali::TypeInfo *)jarg1;
21315   {
21316     try {
21317       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21318     } catch (std::out_of_range& e) {
21319       {
21320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21321       };
21322     } catch (std::exception& e) {
21323       {
21324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21325       };
21326     } catch (Dali::DaliException e) {
21327       {
21328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21329       };
21330     } catch (...) {
21331       {
21332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21333       };
21334     }
21335   }
21336
21337   jresult = SWIG_csharp_string_callback(result->c_str());
21338   return jresult;
21339 }
21340
21341
21342 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21343   char * jresult ;
21344   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21345   std::string *result = 0 ;
21346
21347   arg1 = (Dali::TypeInfo *)jarg1;
21348   {
21349     try {
21350       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21351     } catch (std::out_of_range& e) {
21352       {
21353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21354       };
21355     } catch (std::exception& e) {
21356       {
21357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21358       };
21359     } catch (Dali::DaliException e) {
21360       {
21361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21362       };
21363     } catch (...) {
21364       {
21365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21366       };
21367     }
21368   }
21369
21370   jresult = SWIG_csharp_string_callback(result->c_str());
21371   return jresult;
21372 }
21373
21374
21375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21376   void * jresult ;
21377   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21378   Dali::BaseHandle result;
21379
21380   arg1 = (Dali::TypeInfo *)jarg1;
21381   {
21382     try {
21383       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
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 (Dali::DaliException e) {
21393       {
21394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21395       };
21396     } catch (...) {
21397       {
21398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21399       };
21400     }
21401   }
21402
21403   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21404   return jresult;
21405 }
21406
21407
21408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21409   unsigned long jresult ;
21410   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21411   size_t result;
21412
21413   arg1 = (Dali::TypeInfo *)jarg1;
21414   {
21415     try {
21416       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21417     } catch (std::out_of_range& e) {
21418       {
21419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21420       };
21421     } catch (std::exception& e) {
21422       {
21423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21424       };
21425     } catch (Dali::DaliException e) {
21426       {
21427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21428       };
21429     } catch (...) {
21430       {
21431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21432       };
21433     }
21434   }
21435
21436   jresult = (unsigned long)result;
21437   return jresult;
21438 }
21439
21440
21441 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21442   char * jresult ;
21443   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21444   size_t arg2 ;
21445   std::string result;
21446
21447   arg1 = (Dali::TypeInfo *)jarg1;
21448   arg2 = (size_t)jarg2;
21449   {
21450     try {
21451       result = (arg1)->GetActionName(arg2);
21452     } catch (std::out_of_range& e) {
21453       {
21454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21455       };
21456     } catch (std::exception& e) {
21457       {
21458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21459       };
21460     } catch (Dali::DaliException e) {
21461       {
21462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21463       };
21464     } catch (...) {
21465       {
21466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21467       };
21468     }
21469   }
21470
21471   jresult = SWIG_csharp_string_callback((&result)->c_str());
21472   return jresult;
21473 }
21474
21475
21476 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21477   unsigned long jresult ;
21478   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21479   size_t result;
21480
21481   arg1 = (Dali::TypeInfo *)jarg1;
21482   {
21483     try {
21484       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21485     } catch (std::out_of_range& e) {
21486       {
21487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21488       };
21489     } catch (std::exception& e) {
21490       {
21491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21492       };
21493     } catch (Dali::DaliException e) {
21494       {
21495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21496       };
21497     } catch (...) {
21498       {
21499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21500       };
21501     }
21502   }
21503
21504   jresult = (unsigned long)result;
21505   return jresult;
21506 }
21507
21508
21509 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21510   char * jresult ;
21511   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21512   size_t arg2 ;
21513   std::string result;
21514
21515   arg1 = (Dali::TypeInfo *)jarg1;
21516   arg2 = (size_t)jarg2;
21517   {
21518     try {
21519       result = (arg1)->GetSignalName(arg2);
21520     } catch (std::out_of_range& e) {
21521       {
21522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21523       };
21524     } catch (std::exception& e) {
21525       {
21526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21527       };
21528     } catch (Dali::DaliException e) {
21529       {
21530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21531       };
21532     } catch (...) {
21533       {
21534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21535       };
21536     }
21537   }
21538
21539   jresult = SWIG_csharp_string_callback((&result)->c_str());
21540   return jresult;
21541 }
21542
21543
21544 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21545   unsigned long jresult ;
21546   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21547   size_t result;
21548
21549   arg1 = (Dali::TypeInfo *)jarg1;
21550   {
21551     try {
21552       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21553     } catch (std::out_of_range& e) {
21554       {
21555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21556       };
21557     } catch (std::exception& e) {
21558       {
21559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21560       };
21561     } catch (Dali::DaliException e) {
21562       {
21563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21564       };
21565     } catch (...) {
21566       {
21567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21568       };
21569     }
21570   }
21571
21572   jresult = (unsigned long)result;
21573   return jresult;
21574 }
21575
21576
21577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21578   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21579   Dali::Property::IndexContainer *arg2 = 0 ;
21580
21581   arg1 = (Dali::TypeInfo *)jarg1;
21582   arg2 = (Dali::Property::IndexContainer *)jarg2;
21583   if (!arg2) {
21584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21585     return ;
21586   }
21587   {
21588     try {
21589       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21590     } catch (std::out_of_range& e) {
21591       {
21592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21593       };
21594     } catch (std::exception& e) {
21595       {
21596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21597       };
21598     } catch (Dali::DaliException e) {
21599       {
21600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21601       };
21602     } catch (...) {
21603       {
21604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21605       };
21606     }
21607   }
21608
21609 }
21610
21611
21612 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21613   char * jresult ;
21614   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21615   Dali::Property::Index arg2 ;
21616   std::string *result = 0 ;
21617
21618   arg1 = (Dali::TypeInfo *)jarg1;
21619   arg2 = (Dali::Property::Index)jarg2;
21620   {
21621     try {
21622       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21623     } catch (std::out_of_range& e) {
21624       {
21625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21626       };
21627     } catch (std::exception& e) {
21628       {
21629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21630       };
21631     } catch (Dali::DaliException e) {
21632       {
21633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21634       };
21635     } catch (...) {
21636       {
21637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21638       };
21639     }
21640   }
21641
21642   jresult = SWIG_csharp_string_callback(result->c_str());
21643   return jresult;
21644 }
21645
21646
21647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21648   void * jresult ;
21649   Dali::TypeRegistry result;
21650
21651   {
21652     try {
21653       result = Dali::TypeRegistry::Get();
21654     } catch (std::out_of_range& e) {
21655       {
21656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21657       };
21658     } catch (std::exception& e) {
21659       {
21660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21661       };
21662     } catch (Dali::DaliException e) {
21663       {
21664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21665       };
21666     } catch (...) {
21667       {
21668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21669       };
21670     }
21671   }
21672
21673   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21674   return jresult;
21675 }
21676
21677
21678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21679   void * jresult ;
21680   Dali::TypeRegistry *result = 0 ;
21681
21682   {
21683     try {
21684       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21685     } catch (std::out_of_range& e) {
21686       {
21687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21688       };
21689     } catch (std::exception& e) {
21690       {
21691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21692       };
21693     } catch (Dali::DaliException e) {
21694       {
21695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21696       };
21697     } catch (...) {
21698       {
21699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21700       };
21701     }
21702   }
21703
21704   jresult = (void *)result;
21705   return jresult;
21706 }
21707
21708
21709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21710   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21711
21712   arg1 = (Dali::TypeRegistry *)jarg1;
21713   {
21714     try {
21715       delete arg1;
21716     } catch (std::out_of_range& e) {
21717       {
21718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21719       };
21720     } catch (std::exception& e) {
21721       {
21722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21723       };
21724     } catch (Dali::DaliException e) {
21725       {
21726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21727       };
21728     } catch (...) {
21729       {
21730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21731       };
21732     }
21733   }
21734
21735 }
21736
21737
21738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21739   void * jresult ;
21740   Dali::TypeRegistry *arg1 = 0 ;
21741   Dali::TypeRegistry *result = 0 ;
21742
21743   arg1 = (Dali::TypeRegistry *)jarg1;
21744   if (!arg1) {
21745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21746     return 0;
21747   }
21748   {
21749     try {
21750       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21751     } catch (std::out_of_range& e) {
21752       {
21753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21754       };
21755     } catch (std::exception& e) {
21756       {
21757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21758       };
21759     } catch (Dali::DaliException e) {
21760       {
21761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21762       };
21763     } catch (...) {
21764       {
21765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21766       };
21767     }
21768   }
21769
21770   jresult = (void *)result;
21771   return jresult;
21772 }
21773
21774
21775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21776   void * jresult ;
21777   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21778   Dali::TypeRegistry *arg2 = 0 ;
21779   Dali::TypeRegistry *result = 0 ;
21780
21781   arg1 = (Dali::TypeRegistry *)jarg1;
21782   arg2 = (Dali::TypeRegistry *)jarg2;
21783   if (!arg2) {
21784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21785     return 0;
21786   }
21787   {
21788     try {
21789       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21790     } catch (std::out_of_range& e) {
21791       {
21792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21793       };
21794     } catch (std::exception& e) {
21795       {
21796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21797       };
21798     } catch (Dali::DaliException e) {
21799       {
21800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21801       };
21802     } catch (...) {
21803       {
21804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21805       };
21806     }
21807   }
21808
21809   jresult = (void *)result;
21810   return jresult;
21811 }
21812
21813
21814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21815   void * jresult ;
21816   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21817   std::string *arg2 = 0 ;
21818   Dali::TypeInfo result;
21819
21820   arg1 = (Dali::TypeRegistry *)jarg1;
21821   if (!jarg2) {
21822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21823     return 0;
21824   }
21825   std::string arg2_str(jarg2);
21826   arg2 = &arg2_str;
21827   {
21828     try {
21829       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21830     } catch (std::out_of_range& e) {
21831       {
21832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21833       };
21834     } catch (std::exception& e) {
21835       {
21836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21837       };
21838     } catch (Dali::DaliException e) {
21839       {
21840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21841       };
21842     } catch (...) {
21843       {
21844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21845       };
21846     }
21847   }
21848
21849   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21850
21851   //argout typemap for const std::string&
21852
21853   return jresult;
21854 }
21855
21856
21857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21858   void * jresult ;
21859   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21860   std::type_info *arg2 = 0 ;
21861   Dali::TypeInfo result;
21862
21863   arg1 = (Dali::TypeRegistry *)jarg1;
21864   arg2 = (std::type_info *)jarg2;
21865   if (!arg2) {
21866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21867     return 0;
21868   }
21869   {
21870     try {
21871       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21872     } catch (std::out_of_range& e) {
21873       {
21874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21875       };
21876     } catch (std::exception& e) {
21877       {
21878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21879       };
21880     } catch (Dali::DaliException e) {
21881       {
21882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21883       };
21884     } catch (...) {
21885       {
21886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21887       };
21888     }
21889   }
21890
21891   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21892   return jresult;
21893 }
21894
21895
21896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21897   unsigned long jresult ;
21898   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21899   size_t result;
21900
21901   arg1 = (Dali::TypeRegistry *)jarg1;
21902   {
21903     try {
21904       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21905     } catch (std::out_of_range& e) {
21906       {
21907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21908       };
21909     } catch (std::exception& e) {
21910       {
21911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21912       };
21913     } catch (Dali::DaliException e) {
21914       {
21915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21916       };
21917     } catch (...) {
21918       {
21919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21920       };
21921     }
21922   }
21923
21924   jresult = (unsigned long)result;
21925   return jresult;
21926 }
21927
21928
21929 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21930   char * jresult ;
21931   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21932   size_t arg2 ;
21933   std::string result;
21934
21935   arg1 = (Dali::TypeRegistry *)jarg1;
21936   arg2 = (size_t)jarg2;
21937   {
21938     try {
21939       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21940     } catch (std::out_of_range& e) {
21941       {
21942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21943       };
21944     } catch (std::exception& e) {
21945       {
21946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21947       };
21948     } catch (Dali::DaliException e) {
21949       {
21950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21951       };
21952     } catch (...) {
21953       {
21954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21955       };
21956     }
21957   }
21958
21959   jresult = SWIG_csharp_string_callback((&result)->c_str());
21960   return jresult;
21961 }
21962
21963
21964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21965   void * jresult ;
21966   std::type_info *arg1 = 0 ;
21967   std::type_info *arg2 = 0 ;
21968   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21969   Dali::TypeRegistration *result = 0 ;
21970
21971   arg1 = (std::type_info *)jarg1;
21972   if (!arg1) {
21973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21974     return 0;
21975   }
21976   arg2 = (std::type_info *)jarg2;
21977   if (!arg2) {
21978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21979     return 0;
21980   }
21981   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21982   {
21983     try {
21984       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21985     } catch (std::out_of_range& e) {
21986       {
21987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21988       };
21989     } catch (std::exception& e) {
21990       {
21991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21992       };
21993     } catch (Dali::DaliException e) {
21994       {
21995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21996       };
21997     } catch (...) {
21998       {
21999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22000       };
22001     }
22002   }
22003
22004   jresult = (void *)result;
22005   return jresult;
22006 }
22007
22008
22009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22010   void * jresult ;
22011   std::type_info *arg1 = 0 ;
22012   std::type_info *arg2 = 0 ;
22013   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22014   bool arg4 ;
22015   Dali::TypeRegistration *result = 0 ;
22016
22017   arg1 = (std::type_info *)jarg1;
22018   if (!arg1) {
22019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22020     return 0;
22021   }
22022   arg2 = (std::type_info *)jarg2;
22023   if (!arg2) {
22024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22025     return 0;
22026   }
22027   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22028   arg4 = jarg4 ? true : false;
22029   {
22030     try {
22031       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22032     } catch (std::out_of_range& e) {
22033       {
22034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22035       };
22036     } catch (std::exception& e) {
22037       {
22038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22039       };
22040     } catch (Dali::DaliException e) {
22041       {
22042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22043       };
22044     } catch (...) {
22045       {
22046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22047       };
22048     }
22049   }
22050
22051   jresult = (void *)result;
22052   return jresult;
22053 }
22054
22055
22056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22057   void * jresult ;
22058   std::string *arg1 = 0 ;
22059   std::type_info *arg2 = 0 ;
22060   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22061   Dali::TypeRegistration *result = 0 ;
22062
22063   if (!jarg1) {
22064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22065     return 0;
22066   }
22067   std::string arg1_str(jarg1);
22068   arg1 = &arg1_str;
22069   arg2 = (std::type_info *)jarg2;
22070   if (!arg2) {
22071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22072     return 0;
22073   }
22074   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22075   {
22076     try {
22077       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22078     } catch (std::out_of_range& e) {
22079       {
22080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22081       };
22082     } catch (std::exception& e) {
22083       {
22084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22085       };
22086     } catch (Dali::DaliException e) {
22087       {
22088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22089       };
22090     } catch (...) {
22091       {
22092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22093       };
22094     }
22095   }
22096
22097   jresult = (void *)result;
22098
22099   //argout typemap for const std::string&
22100
22101   return jresult;
22102 }
22103
22104
22105 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22106   char * jresult ;
22107   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22108   std::string result;
22109
22110   arg1 = (Dali::TypeRegistration *)jarg1;
22111   {
22112     try {
22113       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22114     } catch (std::out_of_range& e) {
22115       {
22116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22117       };
22118     } catch (std::exception& e) {
22119       {
22120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22121       };
22122     } catch (Dali::DaliException e) {
22123       {
22124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22125       };
22126     } catch (...) {
22127       {
22128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22129       };
22130     }
22131   }
22132
22133   jresult = SWIG_csharp_string_callback((&result)->c_str());
22134   return jresult;
22135 }
22136
22137
22138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22139   std::string *arg1 = 0 ;
22140   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22141
22142   if (!jarg1) {
22143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22144     return ;
22145   }
22146   std::string arg1_str(jarg1);
22147   arg1 = &arg1_str;
22148   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22149   {
22150     try {
22151       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22152     } catch (std::out_of_range& e) {
22153       {
22154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22155       };
22156     } catch (std::exception& e) {
22157       {
22158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22159       };
22160     } catch (Dali::DaliException e) {
22161       {
22162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22163       };
22164     } catch (...) {
22165       {
22166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22167       };
22168     }
22169   }
22170
22171
22172   //argout typemap for const std::string&
22173
22174 }
22175
22176
22177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22178   std::string *arg1 = 0 ;
22179   std::string *arg2 = 0 ;
22180   int arg3 ;
22181   Dali::Property::Type arg4 ;
22182   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22183   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22184
22185   if (!jarg1) {
22186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22187     return ;
22188   }
22189   std::string arg1_str(jarg1);
22190   arg1 = &arg1_str;
22191   if (!jarg2) {
22192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22193     return ;
22194   }
22195   std::string arg2_str(jarg2);
22196   arg2 = &arg2_str;
22197   arg3 = (int)jarg3;
22198   arg4 = (Dali::Property::Type)jarg4;
22199   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22200   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22201   {
22202     try {
22203       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22204     } catch (std::out_of_range& e) {
22205       {
22206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22207       };
22208     } catch (std::exception& e) {
22209       {
22210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22211       };
22212     } catch (Dali::DaliException e) {
22213       {
22214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22215       };
22216     } catch (...) {
22217       {
22218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22219       };
22220     }
22221   }
22222
22223
22224   //argout typemap for const std::string&
22225
22226
22227   //argout typemap for const std::string&
22228
22229 }
22230
22231
22232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22233   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22234
22235   arg1 = (Dali::TypeRegistration *)jarg1;
22236   {
22237     try {
22238       delete arg1;
22239     } catch (std::out_of_range& e) {
22240       {
22241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22242       };
22243     } catch (std::exception& e) {
22244       {
22245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22246       };
22247     } catch (Dali::DaliException e) {
22248       {
22249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22250       };
22251     } catch (...) {
22252       {
22253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22254       };
22255     }
22256   }
22257
22258 }
22259
22260
22261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22262   void * jresult ;
22263   Dali::TypeRegistration *arg1 = 0 ;
22264   std::string *arg2 = 0 ;
22265   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22266   Dali::SignalConnectorType *result = 0 ;
22267
22268   arg1 = (Dali::TypeRegistration *)jarg1;
22269   if (!arg1) {
22270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22271     return 0;
22272   }
22273   if (!jarg2) {
22274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22275     return 0;
22276   }
22277   std::string arg2_str(jarg2);
22278   arg2 = &arg2_str;
22279   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22280   {
22281     try {
22282       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22283     } catch (std::out_of_range& e) {
22284       {
22285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22286       };
22287     } catch (std::exception& e) {
22288       {
22289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22290       };
22291     } catch (Dali::DaliException e) {
22292       {
22293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22294       };
22295     } catch (...) {
22296       {
22297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22298       };
22299     }
22300   }
22301
22302   jresult = (void *)result;
22303
22304   //argout typemap for const std::string&
22305
22306   return jresult;
22307 }
22308
22309
22310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22311   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22312
22313   arg1 = (Dali::SignalConnectorType *)jarg1;
22314   {
22315     try {
22316       delete arg1;
22317     } catch (std::out_of_range& e) {
22318       {
22319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22320       };
22321     } catch (std::exception& e) {
22322       {
22323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22324       };
22325     } catch (Dali::DaliException e) {
22326       {
22327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22328       };
22329     } catch (...) {
22330       {
22331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22332       };
22333     }
22334   }
22335
22336 }
22337
22338
22339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22340   void * jresult ;
22341   Dali::TypeRegistration *arg1 = 0 ;
22342   std::string *arg2 = 0 ;
22343   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22344   Dali::TypeAction *result = 0 ;
22345
22346   arg1 = (Dali::TypeRegistration *)jarg1;
22347   if (!arg1) {
22348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22349     return 0;
22350   }
22351   if (!jarg2) {
22352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22353     return 0;
22354   }
22355   std::string arg2_str(jarg2);
22356   arg2 = &arg2_str;
22357   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22358   {
22359     try {
22360       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22361     } catch (std::out_of_range& e) {
22362       {
22363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22364       };
22365     } catch (std::exception& e) {
22366       {
22367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22368       };
22369     } catch (Dali::DaliException e) {
22370       {
22371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22372       };
22373     } catch (...) {
22374       {
22375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22376       };
22377     }
22378   }
22379
22380   jresult = (void *)result;
22381
22382   //argout typemap for const std::string&
22383
22384   return jresult;
22385 }
22386
22387
22388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22389   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22390
22391   arg1 = (Dali::TypeAction *)jarg1;
22392   {
22393     try {
22394       delete arg1;
22395     } catch (std::out_of_range& e) {
22396       {
22397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22398       };
22399     } catch (std::exception& e) {
22400       {
22401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22402       };
22403     } catch (Dali::DaliException e) {
22404       {
22405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22406       };
22407     } catch (...) {
22408       {
22409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22410       };
22411     }
22412   }
22413
22414 }
22415
22416
22417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22418   void * jresult ;
22419   Dali::TypeRegistration *arg1 = 0 ;
22420   std::string *arg2 = 0 ;
22421   Dali::Property::Index arg3 ;
22422   Dali::Property::Type arg4 ;
22423   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22424   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22425   Dali::PropertyRegistration *result = 0 ;
22426
22427   arg1 = (Dali::TypeRegistration *)jarg1;
22428   if (!arg1) {
22429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22430     return 0;
22431   }
22432   if (!jarg2) {
22433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22434     return 0;
22435   }
22436   std::string arg2_str(jarg2);
22437   arg2 = &arg2_str;
22438   arg3 = (Dali::Property::Index)jarg3;
22439   arg4 = (Dali::Property::Type)jarg4;
22440   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22441   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22442   {
22443     try {
22444       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22445     } catch (std::out_of_range& e) {
22446       {
22447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22448       };
22449     } catch (std::exception& e) {
22450       {
22451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22452       };
22453     } catch (Dali::DaliException e) {
22454       {
22455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22456       };
22457     } catch (...) {
22458       {
22459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22460       };
22461     }
22462   }
22463
22464   jresult = (void *)result;
22465
22466   //argout typemap for const std::string&
22467
22468   return jresult;
22469 }
22470
22471
22472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22473   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22474
22475   arg1 = (Dali::PropertyRegistration *)jarg1;
22476   {
22477     try {
22478       delete arg1;
22479     } catch (std::out_of_range& e) {
22480       {
22481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22482       };
22483     } catch (std::exception& e) {
22484       {
22485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22486       };
22487     } catch (Dali::DaliException e) {
22488       {
22489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22490       };
22491     } catch (...) {
22492       {
22493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22494       };
22495     }
22496   }
22497
22498 }
22499
22500
22501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22502   void * jresult ;
22503   Dali::TypeRegistration *arg1 = 0 ;
22504   std::string *arg2 = 0 ;
22505   Dali::Property::Index arg3 ;
22506   Dali::Property::Type arg4 ;
22507   Dali::AnimatablePropertyRegistration *result = 0 ;
22508
22509   arg1 = (Dali::TypeRegistration *)jarg1;
22510   if (!arg1) {
22511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22512     return 0;
22513   }
22514   if (!jarg2) {
22515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22516     return 0;
22517   }
22518   std::string arg2_str(jarg2);
22519   arg2 = &arg2_str;
22520   arg3 = (Dali::Property::Index)jarg3;
22521   arg4 = (Dali::Property::Type)jarg4;
22522   {
22523     try {
22524       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22525     } catch (std::out_of_range& e) {
22526       {
22527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22528       };
22529     } catch (std::exception& e) {
22530       {
22531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22532       };
22533     } catch (Dali::DaliException e) {
22534       {
22535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22536       };
22537     } catch (...) {
22538       {
22539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22540       };
22541     }
22542   }
22543
22544   jresult = (void *)result;
22545
22546   //argout typemap for const std::string&
22547
22548   return jresult;
22549 }
22550
22551
22552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22553   void * jresult ;
22554   Dali::TypeRegistration *arg1 = 0 ;
22555   std::string *arg2 = 0 ;
22556   Dali::Property::Index arg3 ;
22557   Dali::Property::Value *arg4 = 0 ;
22558   Dali::AnimatablePropertyRegistration *result = 0 ;
22559
22560   arg1 = (Dali::TypeRegistration *)jarg1;
22561   if (!arg1) {
22562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22563     return 0;
22564   }
22565   if (!jarg2) {
22566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22567     return 0;
22568   }
22569   std::string arg2_str(jarg2);
22570   arg2 = &arg2_str;
22571   arg3 = (Dali::Property::Index)jarg3;
22572   arg4 = (Dali::Property::Value *)jarg4;
22573   if (!arg4) {
22574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22575     return 0;
22576   }
22577   {
22578     try {
22579       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22580     } catch (std::out_of_range& e) {
22581       {
22582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22583       };
22584     } catch (std::exception& e) {
22585       {
22586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22587       };
22588     } catch (Dali::DaliException e) {
22589       {
22590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22591       };
22592     } catch (...) {
22593       {
22594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22595       };
22596     }
22597   }
22598
22599   jresult = (void *)result;
22600
22601   //argout typemap for const std::string&
22602
22603   return jresult;
22604 }
22605
22606
22607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22608   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22609
22610   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22611   {
22612     try {
22613       delete arg1;
22614     } catch (std::out_of_range& e) {
22615       {
22616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22617       };
22618     } catch (std::exception& e) {
22619       {
22620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22621       };
22622     } catch (Dali::DaliException e) {
22623       {
22624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22625       };
22626     } catch (...) {
22627       {
22628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22629       };
22630     }
22631   }
22632
22633 }
22634
22635
22636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22637   void * jresult ;
22638   Dali::TypeRegistration *arg1 = 0 ;
22639   std::string *arg2 = 0 ;
22640   Dali::Property::Index arg3 ;
22641   Dali::Property::Index arg4 ;
22642   unsigned int arg5 ;
22643   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22644
22645   arg1 = (Dali::TypeRegistration *)jarg1;
22646   if (!arg1) {
22647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22648     return 0;
22649   }
22650   if (!jarg2) {
22651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22652     return 0;
22653   }
22654   std::string arg2_str(jarg2);
22655   arg2 = &arg2_str;
22656   arg3 = (Dali::Property::Index)jarg3;
22657   arg4 = (Dali::Property::Index)jarg4;
22658   arg5 = (unsigned int)jarg5;
22659   {
22660     try {
22661       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22662     } catch (std::out_of_range& e) {
22663       {
22664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22665       };
22666     } catch (std::exception& e) {
22667       {
22668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22669       };
22670     } catch (Dali::DaliException e) {
22671       {
22672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22673       };
22674     } catch (...) {
22675       {
22676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22677       };
22678     }
22679   }
22680
22681   jresult = (void *)result;
22682
22683   //argout typemap for const std::string&
22684
22685   return jresult;
22686 }
22687
22688
22689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22690   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22691
22692   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22693   {
22694     try {
22695       delete arg1;
22696     } catch (std::out_of_range& e) {
22697       {
22698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22699       };
22700     } catch (std::exception& e) {
22701       {
22702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22703       };
22704     } catch (Dali::DaliException e) {
22705       {
22706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22707       };
22708     } catch (...) {
22709       {
22710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22711       };
22712     }
22713   }
22714
22715 }
22716
22717
22718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22719   void * jresult ;
22720   Dali::TypeRegistration *arg1 = 0 ;
22721   std::string *arg2 = 0 ;
22722   Dali::Property::Index arg3 ;
22723   Dali::Property::Type arg4 ;
22724   Dali::ChildPropertyRegistration *result = 0 ;
22725
22726   arg1 = (Dali::TypeRegistration *)jarg1;
22727   if (!arg1) {
22728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22729     return 0;
22730   }
22731   if (!jarg2) {
22732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22733     return 0;
22734   }
22735   std::string arg2_str(jarg2);
22736   arg2 = &arg2_str;
22737   arg3 = (Dali::Property::Index)jarg3;
22738   arg4 = (Dali::Property::Type)jarg4;
22739   {
22740     try {
22741       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22742     } catch (std::out_of_range& e) {
22743       {
22744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22745       };
22746     } catch (std::exception& e) {
22747       {
22748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22749       };
22750     } catch (Dali::DaliException e) {
22751       {
22752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22753       };
22754     } catch (...) {
22755       {
22756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22757       };
22758     }
22759   }
22760
22761   jresult = (void *)result;
22762
22763   //argout typemap for const std::string&
22764
22765   return jresult;
22766 }
22767
22768
22769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22770   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22771
22772   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22773   {
22774     try {
22775       delete arg1;
22776     } catch (std::out_of_range& e) {
22777       {
22778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22779       };
22780     } catch (std::exception& e) {
22781       {
22782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22783       };
22784     } catch (Dali::DaliException e) {
22785       {
22786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22787       };
22788     } catch (...) {
22789       {
22790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22791       };
22792     }
22793   }
22794
22795 }
22796
22797
22798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22799   unsigned int jresult ;
22800   std::string *arg1 = 0 ;
22801   std::type_info *arg2 = 0 ;
22802   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22803   bool result;
22804
22805   if (!jarg1) {
22806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22807     return 0;
22808   }
22809   std::string arg1_str(jarg1);
22810   arg1 = &arg1_str;
22811   arg2 = (std::type_info *)jarg2;
22812   if (!arg2) {
22813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22814     return 0;
22815   }
22816   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22817   {
22818     try {
22819       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22820     } catch (std::out_of_range& e) {
22821       {
22822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22823       };
22824     } catch (std::exception& e) {
22825       {
22826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22827       };
22828     } catch (Dali::DaliException e) {
22829       {
22830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22831       };
22832     } catch (...) {
22833       {
22834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22835       };
22836     }
22837   }
22838
22839   jresult = result;
22840
22841   //argout typemap for const std::string&
22842
22843   return jresult;
22844 }
22845
22846
22847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22848   unsigned int jresult ;
22849   std::string *arg1 = 0 ;
22850   std::string *arg2 = 0 ;
22851   Dali::Property::Index arg3 ;
22852   Dali::Property::Type arg4 ;
22853   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22854   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22855   bool result;
22856
22857   if (!jarg1) {
22858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22859     return 0;
22860   }
22861   std::string arg1_str(jarg1);
22862   arg1 = &arg1_str;
22863   if (!jarg2) {
22864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22865     return 0;
22866   }
22867   std::string arg2_str(jarg2);
22868   arg2 = &arg2_str;
22869   arg3 = (Dali::Property::Index)jarg3;
22870   arg4 = (Dali::Property::Type)jarg4;
22871   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22872   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22873   {
22874     try {
22875       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22876     } catch (std::out_of_range& e) {
22877       {
22878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22879       };
22880     } catch (std::exception& e) {
22881       {
22882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22883       };
22884     } catch (Dali::DaliException e) {
22885       {
22886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22887       };
22888     } catch (...) {
22889       {
22890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22891       };
22892     }
22893   }
22894
22895   jresult = result;
22896
22897   //argout typemap for const std::string&
22898
22899
22900   //argout typemap for const std::string&
22901
22902   return jresult;
22903 }
22904
22905
22906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22907   float jresult ;
22908   float result;
22909
22910   result = (float)(float)Dali::ParentOrigin::TOP;
22911   jresult = result;
22912   return jresult;
22913 }
22914
22915
22916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22917   float jresult ;
22918   float result;
22919
22920   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22921   jresult = result;
22922   return jresult;
22923 }
22924
22925
22926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22927   float jresult ;
22928   float result;
22929
22930   result = (float)(float)Dali::ParentOrigin::LEFT;
22931   jresult = result;
22932   return jresult;
22933 }
22934
22935
22936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22937   float jresult ;
22938   float result;
22939
22940   result = (float)(float)Dali::ParentOrigin::RIGHT;
22941   jresult = result;
22942   return jresult;
22943 }
22944
22945
22946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22947   float jresult ;
22948   float result;
22949
22950   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22951   jresult = result;
22952   return jresult;
22953 }
22954
22955
22956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22957   void * jresult ;
22958   Dali::Vector3 *result = 0 ;
22959
22960   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22961   jresult = (void *)result;
22962   return jresult;
22963 }
22964
22965
22966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22967   void * jresult ;
22968   Dali::Vector3 *result = 0 ;
22969
22970   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22971   jresult = (void *)result;
22972   return jresult;
22973 }
22974
22975
22976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22977   void * jresult ;
22978   Dali::Vector3 *result = 0 ;
22979
22980   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22981   jresult = (void *)result;
22982   return jresult;
22983 }
22984
22985
22986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22987   void * jresult ;
22988   Dali::Vector3 *result = 0 ;
22989
22990   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22991   jresult = (void *)result;
22992   return jresult;
22993 }
22994
22995
22996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22997   void * jresult ;
22998   Dali::Vector3 *result = 0 ;
22999
23000   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23001   jresult = (void *)result;
23002   return jresult;
23003 }
23004
23005
23006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23007   void * jresult ;
23008   Dali::Vector3 *result = 0 ;
23009
23010   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23011   jresult = (void *)result;
23012   return jresult;
23013 }
23014
23015
23016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23017   void * jresult ;
23018   Dali::Vector3 *result = 0 ;
23019
23020   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23021   jresult = (void *)result;
23022   return jresult;
23023 }
23024
23025
23026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23027   void * jresult ;
23028   Dali::Vector3 *result = 0 ;
23029
23030   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23031   jresult = (void *)result;
23032   return jresult;
23033 }
23034
23035
23036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23037   void * jresult ;
23038   Dali::Vector3 *result = 0 ;
23039
23040   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23041   jresult = (void *)result;
23042   return jresult;
23043 }
23044
23045
23046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23047   float jresult ;
23048   float result;
23049
23050   result = (float)(float)Dali::AnchorPoint::TOP;
23051   jresult = result;
23052   return jresult;
23053 }
23054
23055
23056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23057   float jresult ;
23058   float result;
23059
23060   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23061   jresult = result;
23062   return jresult;
23063 }
23064
23065
23066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23067   float jresult ;
23068   float result;
23069
23070   result = (float)(float)Dali::AnchorPoint::LEFT;
23071   jresult = result;
23072   return jresult;
23073 }
23074
23075
23076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23077   float jresult ;
23078   float result;
23079
23080   result = (float)(float)Dali::AnchorPoint::RIGHT;
23081   jresult = result;
23082   return jresult;
23083 }
23084
23085
23086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23087   float jresult ;
23088   float result;
23089
23090   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23091   jresult = result;
23092   return jresult;
23093 }
23094
23095
23096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23097   void * jresult ;
23098   Dali::Vector3 *result = 0 ;
23099
23100   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23101   jresult = (void *)result;
23102   return jresult;
23103 }
23104
23105
23106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23107   void * jresult ;
23108   Dali::Vector3 *result = 0 ;
23109
23110   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23111   jresult = (void *)result;
23112   return jresult;
23113 }
23114
23115
23116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23117   void * jresult ;
23118   Dali::Vector3 *result = 0 ;
23119
23120   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23121   jresult = (void *)result;
23122   return jresult;
23123 }
23124
23125
23126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23127   void * jresult ;
23128   Dali::Vector3 *result = 0 ;
23129
23130   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23131   jresult = (void *)result;
23132   return jresult;
23133 }
23134
23135
23136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23137   void * jresult ;
23138   Dali::Vector3 *result = 0 ;
23139
23140   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23141   jresult = (void *)result;
23142   return jresult;
23143 }
23144
23145
23146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23147   void * jresult ;
23148   Dali::Vector3 *result = 0 ;
23149
23150   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23151   jresult = (void *)result;
23152   return jresult;
23153 }
23154
23155
23156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23157   void * jresult ;
23158   Dali::Vector3 *result = 0 ;
23159
23160   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23161   jresult = (void *)result;
23162   return jresult;
23163 }
23164
23165
23166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23167   void * jresult ;
23168   Dali::Vector3 *result = 0 ;
23169
23170   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23171   jresult = (void *)result;
23172   return jresult;
23173 }
23174
23175
23176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23177   void * jresult ;
23178   Dali::Vector3 *result = 0 ;
23179
23180   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23181   jresult = (void *)result;
23182   return jresult;
23183 }
23184
23185
23186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23187   void * jresult ;
23188   Dali::Vector4 *result = 0 ;
23189
23190   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23191   jresult = (void *)result;
23192   return jresult;
23193 }
23194
23195
23196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23197   void * jresult ;
23198   Dali::Vector4 *result = 0 ;
23199
23200   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23201   jresult = (void *)result;
23202   return jresult;
23203 }
23204
23205
23206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23207   void * jresult ;
23208   Dali::Vector4 *result = 0 ;
23209
23210   result = (Dali::Vector4 *)&Dali::Color::RED;
23211   jresult = (void *)result;
23212   return jresult;
23213 }
23214
23215
23216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23217   void * jresult ;
23218   Dali::Vector4 *result = 0 ;
23219
23220   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23221   jresult = (void *)result;
23222   return jresult;
23223 }
23224
23225
23226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23227   void * jresult ;
23228   Dali::Vector4 *result = 0 ;
23229
23230   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23231   jresult = (void *)result;
23232   return jresult;
23233 }
23234
23235
23236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23237   void * jresult ;
23238   Dali::Vector4 *result = 0 ;
23239
23240   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23241   jresult = (void *)result;
23242   return jresult;
23243 }
23244
23245
23246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23247   void * jresult ;
23248   Dali::Vector4 *result = 0 ;
23249
23250   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23251   jresult = (void *)result;
23252   return jresult;
23253 }
23254
23255
23256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23257   void * jresult ;
23258   Dali::Vector4 *result = 0 ;
23259
23260   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23261   jresult = (void *)result;
23262   return jresult;
23263 }
23264
23265
23266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23267   void * jresult ;
23268   Dali::Vector4 *result = 0 ;
23269
23270   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23271   jresult = (void *)result;
23272   return jresult;
23273 }
23274
23275
23276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23277   float jresult ;
23278   float result;
23279
23280   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23281   jresult = result;
23282   return jresult;
23283 }
23284
23285
23286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23287   float jresult ;
23288   float result;
23289
23290   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23291   jresult = result;
23292   return jresult;
23293 }
23294
23295
23296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23297   float jresult ;
23298   float result;
23299
23300   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23301   jresult = result;
23302   return jresult;
23303 }
23304
23305
23306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23307   float jresult ;
23308   float result;
23309
23310   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23311   jresult = result;
23312   return jresult;
23313 }
23314
23315
23316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23317   float jresult ;
23318   float result;
23319
23320   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23321   jresult = result;
23322   return jresult;
23323 }
23324
23325
23326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23327   float jresult ;
23328   float result;
23329
23330   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23331   jresult = result;
23332   return jresult;
23333 }
23334
23335
23336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23337   float jresult ;
23338   float result;
23339
23340   result = (float)(float)Dali::Math::PI;
23341   jresult = result;
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23347   float jresult ;
23348   float result;
23349
23350   result = (float)(float)Dali::Math::PI_2;
23351   jresult = result;
23352   return jresult;
23353 }
23354
23355
23356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23357   float jresult ;
23358   float result;
23359
23360   result = (float)(float)Dali::Math::PI_4;
23361   jresult = result;
23362   return jresult;
23363 }
23364
23365
23366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23367   float jresult ;
23368   float result;
23369
23370   result = (float)(float)Dali::Math::PI_OVER_180;
23371   jresult = result;
23372   return jresult;
23373 }
23374
23375
23376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23377   float jresult ;
23378   float result;
23379
23380   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23381   jresult = result;
23382   return jresult;
23383 }
23384
23385
23386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23387   int jresult ;
23388   Dali::ResizePolicy::Type result;
23389
23390   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23391   jresult = (int)result;
23392   return jresult;
23393 }
23394
23395
23396 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23397   unsigned long jresult ;
23398   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23399   Dali::VectorBase::SizeType result;
23400
23401   arg1 = (Dali::VectorBase *)jarg1;
23402   {
23403     try {
23404       result = ((Dali::VectorBase const *)arg1)->Count();
23405     } catch (std::out_of_range& e) {
23406       {
23407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23408       };
23409     } catch (std::exception& e) {
23410       {
23411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23412       };
23413     } catch (Dali::DaliException e) {
23414       {
23415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23416       };
23417     } catch (...) {
23418       {
23419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23420       };
23421     }
23422   }
23423
23424   jresult = (unsigned long)result;
23425   return jresult;
23426 }
23427
23428
23429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23430   unsigned long jresult ;
23431   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23432   Dali::VectorBase::SizeType result;
23433
23434   arg1 = (Dali::VectorBase *)jarg1;
23435   {
23436     try {
23437       result = ((Dali::VectorBase const *)arg1)->Size();
23438     } catch (std::out_of_range& e) {
23439       {
23440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23441       };
23442     } catch (std::exception& e) {
23443       {
23444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23445       };
23446     } catch (Dali::DaliException e) {
23447       {
23448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23449       };
23450     } catch (...) {
23451       {
23452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23453       };
23454     }
23455   }
23456
23457   jresult = (unsigned long)result;
23458   return jresult;
23459 }
23460
23461
23462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23463   unsigned int jresult ;
23464   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23465   bool result;
23466
23467   arg1 = (Dali::VectorBase *)jarg1;
23468   {
23469     try {
23470       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23471     } catch (std::out_of_range& e) {
23472       {
23473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23474       };
23475     } catch (std::exception& e) {
23476       {
23477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23478       };
23479     } catch (Dali::DaliException e) {
23480       {
23481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23482       };
23483     } catch (...) {
23484       {
23485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23486       };
23487     }
23488   }
23489
23490   jresult = result;
23491   return jresult;
23492 }
23493
23494
23495 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23496   unsigned long jresult ;
23497   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23498   Dali::VectorBase::SizeType result;
23499
23500   arg1 = (Dali::VectorBase *)jarg1;
23501   {
23502     try {
23503       result = ((Dali::VectorBase const *)arg1)->Capacity();
23504     } catch (std::out_of_range& e) {
23505       {
23506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23507       };
23508     } catch (std::exception& e) {
23509       {
23510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23511       };
23512     } catch (Dali::DaliException e) {
23513       {
23514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23515       };
23516     } catch (...) {
23517       {
23518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23519       };
23520     }
23521   }
23522
23523   jresult = (unsigned long)result;
23524   return jresult;
23525 }
23526
23527
23528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23529   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23530
23531   arg1 = (Dali::VectorBase *)jarg1;
23532   {
23533     try {
23534       (arg1)->Release();
23535     } catch (std::out_of_range& e) {
23536       {
23537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23538       };
23539     } catch (std::exception& e) {
23540       {
23541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23542       };
23543     } catch (Dali::DaliException e) {
23544       {
23545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23546       };
23547     } catch (...) {
23548       {
23549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23550       };
23551     }
23552   }
23553
23554 }
23555
23556
23557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23558   void * jresult ;
23559   Dali::Image *result = 0 ;
23560
23561   {
23562     try {
23563       result = (Dali::Image *)new Dali::Image();
23564     } catch (std::out_of_range& e) {
23565       {
23566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23567       };
23568     } catch (std::exception& e) {
23569       {
23570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23571       };
23572     } catch (Dali::DaliException e) {
23573       {
23574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23575       };
23576     } catch (...) {
23577       {
23578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23579       };
23580     }
23581   }
23582
23583   jresult = (void *)result;
23584   return jresult;
23585 }
23586
23587
23588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23589   Dali::Image *arg1 = (Dali::Image *) 0 ;
23590
23591   arg1 = (Dali::Image *)jarg1;
23592   {
23593     try {
23594       delete arg1;
23595     } catch (std::out_of_range& e) {
23596       {
23597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23598       };
23599     } catch (std::exception& e) {
23600       {
23601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23602       };
23603     } catch (Dali::DaliException e) {
23604       {
23605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23606       };
23607     } catch (...) {
23608       {
23609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23610       };
23611     }
23612   }
23613
23614 }
23615
23616
23617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23618   void * jresult ;
23619   Dali::Image *arg1 = 0 ;
23620   Dali::Image *result = 0 ;
23621
23622   arg1 = (Dali::Image *)jarg1;
23623   if (!arg1) {
23624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23625     return 0;
23626   }
23627   {
23628     try {
23629       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23630     } catch (std::out_of_range& e) {
23631       {
23632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23633       };
23634     } catch (std::exception& e) {
23635       {
23636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23637       };
23638     } catch (Dali::DaliException e) {
23639       {
23640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23641       };
23642     } catch (...) {
23643       {
23644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23645       };
23646     }
23647   }
23648
23649   jresult = (void *)result;
23650   return jresult;
23651 }
23652
23653
23654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23655   void * jresult ;
23656   Dali::Image *arg1 = (Dali::Image *) 0 ;
23657   Dali::Image *arg2 = 0 ;
23658   Dali::Image *result = 0 ;
23659
23660   arg1 = (Dali::Image *)jarg1;
23661   arg2 = (Dali::Image *)jarg2;
23662   if (!arg2) {
23663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23664     return 0;
23665   }
23666   {
23667     try {
23668       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23669     } catch (std::out_of_range& e) {
23670       {
23671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23672       };
23673     } catch (std::exception& e) {
23674       {
23675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23676       };
23677     } catch (Dali::DaliException e) {
23678       {
23679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23680       };
23681     } catch (...) {
23682       {
23683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23684       };
23685     }
23686   }
23687
23688   jresult = (void *)result;
23689   return jresult;
23690 }
23691
23692
23693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23694   void * jresult ;
23695   Dali::BaseHandle arg1 ;
23696   Dali::BaseHandle *argp1 ;
23697   Dali::Image result;
23698
23699   argp1 = (Dali::BaseHandle *)jarg1;
23700   if (!argp1) {
23701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23702     return 0;
23703   }
23704   arg1 = *argp1;
23705   {
23706     try {
23707       result = Dali::Image::DownCast(arg1);
23708     } catch (std::out_of_range& e) {
23709       {
23710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23711       };
23712     } catch (std::exception& e) {
23713       {
23714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23715       };
23716     } catch (Dali::DaliException e) {
23717       {
23718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23719       };
23720     } catch (...) {
23721       {
23722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23723       };
23724     }
23725   }
23726
23727   jresult = new Dali::Image((const Dali::Image &)result);
23728   return jresult;
23729 }
23730
23731
23732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23733   unsigned int jresult ;
23734   Dali::Image *arg1 = (Dali::Image *) 0 ;
23735   unsigned int result;
23736
23737   arg1 = (Dali::Image *)jarg1;
23738   {
23739     try {
23740       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23741     } catch (std::out_of_range& e) {
23742       {
23743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23744       };
23745     } catch (std::exception& e) {
23746       {
23747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23748       };
23749     } catch (Dali::DaliException e) {
23750       {
23751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23752       };
23753     } catch (...) {
23754       {
23755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23756       };
23757     }
23758   }
23759
23760   jresult = result;
23761   return jresult;
23762 }
23763
23764
23765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23766   unsigned int jresult ;
23767   Dali::Image *arg1 = (Dali::Image *) 0 ;
23768   unsigned int result;
23769
23770   arg1 = (Dali::Image *)jarg1;
23771   {
23772     try {
23773       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23774     } catch (std::out_of_range& e) {
23775       {
23776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23777       };
23778     } catch (std::exception& e) {
23779       {
23780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23781       };
23782     } catch (Dali::DaliException e) {
23783       {
23784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23785       };
23786     } catch (...) {
23787       {
23788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23789       };
23790     }
23791   }
23792
23793   jresult = result;
23794   return jresult;
23795 }
23796
23797
23798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23799   void * jresult ;
23800   Dali::Image *arg1 = (Dali::Image *) 0 ;
23801   Dali::Image::ImageSignalType *result = 0 ;
23802
23803   arg1 = (Dali::Image *)jarg1;
23804   {
23805     try {
23806       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23807     } catch (std::out_of_range& e) {
23808       {
23809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23810       };
23811     } catch (std::exception& e) {
23812       {
23813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23814       };
23815     } catch (Dali::DaliException e) {
23816       {
23817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23818       };
23819     } catch (...) {
23820       {
23821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23822       };
23823     }
23824   }
23825
23826   jresult = (void *)result;
23827   return jresult;
23828 }
23829
23830
23831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23832   int jresult ;
23833   Dali::Pixel::Format result;
23834
23835   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23836   jresult = (int)result;
23837   return jresult;
23838 }
23839
23840
23841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23842   int jresult ;
23843   Dali::Pixel::Format result;
23844
23845   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23846   jresult = (int)result;
23847   return jresult;
23848 }
23849
23850
23851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23852   unsigned int jresult ;
23853   Dali::Pixel::Format arg1 ;
23854   bool result;
23855
23856   arg1 = (Dali::Pixel::Format)jarg1;
23857   {
23858     try {
23859       result = (bool)Dali::Pixel::HasAlpha(arg1);
23860     } catch (std::out_of_range& e) {
23861       {
23862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23863       };
23864     } catch (std::exception& e) {
23865       {
23866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23867       };
23868     } catch (Dali::DaliException e) {
23869       {
23870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23871       };
23872     } catch (...) {
23873       {
23874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23875       };
23876     }
23877   }
23878
23879   jresult = result;
23880   return jresult;
23881 }
23882
23883
23884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23885   unsigned int jresult ;
23886   Dali::Pixel::Format arg1 ;
23887   unsigned int result;
23888
23889   arg1 = (Dali::Pixel::Format)jarg1;
23890   {
23891     try {
23892       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23893     } catch (std::out_of_range& e) {
23894       {
23895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23896       };
23897     } catch (std::exception& e) {
23898       {
23899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23900       };
23901     } catch (Dali::DaliException e) {
23902       {
23903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23904       };
23905     } catch (...) {
23906       {
23907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23908       };
23909     }
23910   }
23911
23912   jresult = result;
23913   return jresult;
23914 }
23915
23916
23917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23918   Dali::Pixel::Format arg1 ;
23919   int *arg2 = 0 ;
23920   int *arg3 = 0 ;
23921
23922   arg1 = (Dali::Pixel::Format)jarg1;
23923   arg2 = (int *)jarg2;
23924   if (!arg2) {
23925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23926     return ;
23927   }
23928   arg3 = (int *)jarg3;
23929   if (!arg3) {
23930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23931     return ;
23932   }
23933   {
23934     try {
23935       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23936     } catch (std::out_of_range& e) {
23937       {
23938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23939       };
23940     } catch (std::exception& e) {
23941       {
23942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23943       };
23944     } catch (Dali::DaliException e) {
23945       {
23946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23947       };
23948     } catch (...) {
23949       {
23950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23951       };
23952     }
23953   }
23954
23955 }
23956
23957
23958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23959   void * jresult ;
23960   unsigned char *arg1 = (unsigned char *) 0 ;
23961   unsigned int arg2 ;
23962   unsigned int arg3 ;
23963   unsigned int arg4 ;
23964   Dali::Pixel::Format arg5 ;
23965   Dali::PixelData::ReleaseFunction arg6 ;
23966   Dali::PixelData result;
23967
23968   arg1 = jarg1;
23969   arg2 = (unsigned int)jarg2;
23970   arg3 = (unsigned int)jarg3;
23971   arg4 = (unsigned int)jarg4;
23972   arg5 = (Dali::Pixel::Format)jarg5;
23973   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23974   {
23975     try {
23976       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23977     } catch (std::out_of_range& e) {
23978       {
23979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23980       };
23981     } catch (std::exception& e) {
23982       {
23983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23984       };
23985     } catch (Dali::DaliException e) {
23986       {
23987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23988       };
23989     } catch (...) {
23990       {
23991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23992       };
23993     }
23994   }
23995
23996   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23997
23998
23999   return jresult;
24000 }
24001
24002
24003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24004   void * jresult ;
24005   Dali::PixelData *result = 0 ;
24006
24007   {
24008     try {
24009       result = (Dali::PixelData *)new Dali::PixelData();
24010     } catch (std::out_of_range& e) {
24011       {
24012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24013       };
24014     } catch (std::exception& e) {
24015       {
24016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24017       };
24018     } catch (Dali::DaliException e) {
24019       {
24020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24021       };
24022     } catch (...) {
24023       {
24024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24025       };
24026     }
24027   }
24028
24029   jresult = (void *)result;
24030   return jresult;
24031 }
24032
24033
24034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24035   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24036
24037   arg1 = (Dali::PixelData *)jarg1;
24038   {
24039     try {
24040       delete arg1;
24041     } catch (std::out_of_range& e) {
24042       {
24043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24044       };
24045     } catch (std::exception& e) {
24046       {
24047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24048       };
24049     } catch (Dali::DaliException e) {
24050       {
24051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24052       };
24053     } catch (...) {
24054       {
24055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24056       };
24057     }
24058   }
24059
24060 }
24061
24062
24063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24064   void * jresult ;
24065   Dali::PixelData *arg1 = 0 ;
24066   Dali::PixelData *result = 0 ;
24067
24068   arg1 = (Dali::PixelData *)jarg1;
24069   if (!arg1) {
24070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24071     return 0;
24072   }
24073   {
24074     try {
24075       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24076     } catch (std::out_of_range& e) {
24077       {
24078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24079       };
24080     } catch (std::exception& e) {
24081       {
24082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24083       };
24084     } catch (Dali::DaliException e) {
24085       {
24086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24087       };
24088     } catch (...) {
24089       {
24090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24091       };
24092     }
24093   }
24094
24095   jresult = (void *)result;
24096   return jresult;
24097 }
24098
24099
24100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24101   void * jresult ;
24102   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24103   Dali::PixelData *arg2 = 0 ;
24104   Dali::PixelData *result = 0 ;
24105
24106   arg1 = (Dali::PixelData *)jarg1;
24107   arg2 = (Dali::PixelData *)jarg2;
24108   if (!arg2) {
24109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24110     return 0;
24111   }
24112   {
24113     try {
24114       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24115     } catch (std::out_of_range& e) {
24116       {
24117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24118       };
24119     } catch (std::exception& e) {
24120       {
24121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24122       };
24123     } catch (Dali::DaliException e) {
24124       {
24125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24126       };
24127     } catch (...) {
24128       {
24129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24130       };
24131     }
24132   }
24133
24134   jresult = (void *)result;
24135   return jresult;
24136 }
24137
24138
24139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24140   unsigned int jresult ;
24141   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24142   unsigned int result;
24143
24144   arg1 = (Dali::PixelData *)jarg1;
24145   {
24146     try {
24147       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24148     } catch (std::out_of_range& e) {
24149       {
24150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24151       };
24152     } catch (std::exception& e) {
24153       {
24154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24155       };
24156     } catch (Dali::DaliException e) {
24157       {
24158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24159       };
24160     } catch (...) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24163       };
24164     }
24165   }
24166
24167   jresult = result;
24168   return jresult;
24169 }
24170
24171
24172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24173   unsigned int jresult ;
24174   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24175   unsigned int result;
24176
24177   arg1 = (Dali::PixelData *)jarg1;
24178   {
24179     try {
24180       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24181     } catch (std::out_of_range& e) {
24182       {
24183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24184       };
24185     } catch (std::exception& e) {
24186       {
24187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24188       };
24189     } catch (Dali::DaliException e) {
24190       {
24191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24192       };
24193     } catch (...) {
24194       {
24195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24196       };
24197     }
24198   }
24199
24200   jresult = result;
24201   return jresult;
24202 }
24203
24204
24205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24206   int jresult ;
24207   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24208   Dali::Pixel::Format result;
24209
24210   arg1 = (Dali::PixelData *)jarg1;
24211   {
24212     try {
24213       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24214     } catch (std::out_of_range& e) {
24215       {
24216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24217       };
24218     } catch (std::exception& e) {
24219       {
24220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24221       };
24222     } catch (Dali::DaliException e) {
24223       {
24224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24225       };
24226     } catch (...) {
24227       {
24228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24229       };
24230     }
24231   }
24232
24233   jresult = (int)result;
24234   return jresult;
24235 }
24236
24237
24238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24239   unsigned int jresult ;
24240   unsigned int result;
24241
24242   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24243   jresult = result;
24244   return jresult;
24245 }
24246
24247
24248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24249   unsigned int jresult ;
24250   unsigned int result;
24251
24252   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24253   jresult = result;
24254   return jresult;
24255 }
24256
24257
24258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24259   unsigned int jresult ;
24260   unsigned int result;
24261
24262   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24263   jresult = result;
24264   return jresult;
24265 }
24266
24267
24268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24269   unsigned int jresult ;
24270   unsigned int result;
24271
24272   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24273   jresult = result;
24274   return jresult;
24275 }
24276
24277
24278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24279   unsigned int jresult ;
24280   unsigned int result;
24281
24282   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24283   jresult = result;
24284   return jresult;
24285 }
24286
24287
24288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24289   unsigned int jresult ;
24290   unsigned int result;
24291
24292   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24293   jresult = result;
24294   return jresult;
24295 }
24296
24297
24298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24299   void * jresult ;
24300   Dali::TextureType::Type arg1 ;
24301   Dali::Pixel::Format arg2 ;
24302   unsigned int arg3 ;
24303   unsigned int arg4 ;
24304   Dali::Texture result;
24305
24306   arg1 = (Dali::TextureType::Type)jarg1;
24307   arg2 = (Dali::Pixel::Format)jarg2;
24308   arg3 = (unsigned int)jarg3;
24309   arg4 = (unsigned int)jarg4;
24310   {
24311     try {
24312       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24313     } catch (std::out_of_range& e) {
24314       {
24315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24316       };
24317     } catch (std::exception& e) {
24318       {
24319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24320       };
24321     } catch (Dali::DaliException e) {
24322       {
24323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24324       };
24325     } catch (...) {
24326       {
24327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24328       };
24329     }
24330   }
24331
24332   jresult = new Dali::Texture((const Dali::Texture &)result);
24333   return jresult;
24334 }
24335
24336
24337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24338   void * jresult ;
24339   NativeImageInterface *arg1 = 0 ;
24340   Dali::Texture result;
24341
24342   arg1 = (NativeImageInterface *)jarg1;
24343   if (!arg1) {
24344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24345     return 0;
24346   }
24347   {
24348     try {
24349       result = Dali::Texture::New(*arg1);
24350     } catch (std::out_of_range& e) {
24351       {
24352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24353       };
24354     } catch (std::exception& e) {
24355       {
24356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24357       };
24358     } catch (Dali::DaliException e) {
24359       {
24360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24361       };
24362     } catch (...) {
24363       {
24364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24365       };
24366     }
24367   }
24368
24369   jresult = new Dali::Texture((const Dali::Texture &)result);
24370   return jresult;
24371 }
24372
24373
24374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24375   void * jresult ;
24376   Dali::Texture *result = 0 ;
24377
24378   {
24379     try {
24380       result = (Dali::Texture *)new Dali::Texture();
24381     } catch (std::out_of_range& e) {
24382       {
24383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24384       };
24385     } catch (std::exception& e) {
24386       {
24387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24388       };
24389     } catch (Dali::DaliException e) {
24390       {
24391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24392       };
24393     } catch (...) {
24394       {
24395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24396       };
24397     }
24398   }
24399
24400   jresult = (void *)result;
24401   return jresult;
24402 }
24403
24404
24405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24406   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24407
24408   arg1 = (Dali::Texture *)jarg1;
24409   {
24410     try {
24411       delete arg1;
24412     } catch (std::out_of_range& e) {
24413       {
24414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24415       };
24416     } catch (std::exception& e) {
24417       {
24418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24419       };
24420     } catch (Dali::DaliException e) {
24421       {
24422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24423       };
24424     } catch (...) {
24425       {
24426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24427       };
24428     }
24429   }
24430
24431 }
24432
24433
24434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24435   void * jresult ;
24436   Dali::Texture *arg1 = 0 ;
24437   Dali::Texture *result = 0 ;
24438
24439   arg1 = (Dali::Texture *)jarg1;
24440   if (!arg1) {
24441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24442     return 0;
24443   }
24444   {
24445     try {
24446       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24447     } catch (std::out_of_range& e) {
24448       {
24449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24450       };
24451     } catch (std::exception& e) {
24452       {
24453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24454       };
24455     } catch (Dali::DaliException e) {
24456       {
24457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24458       };
24459     } catch (...) {
24460       {
24461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24462       };
24463     }
24464   }
24465
24466   jresult = (void *)result;
24467   return jresult;
24468 }
24469
24470
24471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24472   void * jresult ;
24473   Dali::BaseHandle arg1 ;
24474   Dali::BaseHandle *argp1 ;
24475   Dali::Texture result;
24476
24477   argp1 = (Dali::BaseHandle *)jarg1;
24478   if (!argp1) {
24479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24480     return 0;
24481   }
24482   arg1 = *argp1;
24483   {
24484     try {
24485       result = Dali::Texture::DownCast(arg1);
24486     } catch (std::out_of_range& e) {
24487       {
24488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24489       };
24490     } catch (std::exception& e) {
24491       {
24492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24493       };
24494     } catch (Dali::DaliException e) {
24495       {
24496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24497       };
24498     } catch (...) {
24499       {
24500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24501       };
24502     }
24503   }
24504
24505   jresult = new Dali::Texture((const Dali::Texture &)result);
24506   return jresult;
24507 }
24508
24509
24510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24511   void * jresult ;
24512   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24513   Dali::Texture *arg2 = 0 ;
24514   Dali::Texture *result = 0 ;
24515
24516   arg1 = (Dali::Texture *)jarg1;
24517   arg2 = (Dali::Texture *)jarg2;
24518   if (!arg2) {
24519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24520     return 0;
24521   }
24522   {
24523     try {
24524       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24525     } catch (std::out_of_range& e) {
24526       {
24527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24528       };
24529     } catch (std::exception& e) {
24530       {
24531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24532       };
24533     } catch (Dali::DaliException e) {
24534       {
24535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24536       };
24537     } catch (...) {
24538       {
24539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24540       };
24541     }
24542   }
24543
24544   jresult = (void *)result;
24545   return jresult;
24546 }
24547
24548
24549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24550   unsigned int jresult ;
24551   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24552   Dali::PixelData arg2 ;
24553   Dali::PixelData *argp2 ;
24554   bool result;
24555
24556   arg1 = (Dali::Texture *)jarg1;
24557   argp2 = (Dali::PixelData *)jarg2;
24558   if (!argp2) {
24559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24560     return 0;
24561   }
24562   arg2 = *argp2;
24563   {
24564     try {
24565       result = (bool)(arg1)->Upload(arg2);
24566     } catch (std::out_of_range& e) {
24567       {
24568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24569       };
24570     } catch (std::exception& e) {
24571       {
24572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24573       };
24574     } catch (Dali::DaliException e) {
24575       {
24576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24577       };
24578     } catch (...) {
24579       {
24580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24581       };
24582     }
24583   }
24584
24585   jresult = result;
24586   return jresult;
24587 }
24588
24589
24590 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) {
24591   unsigned int jresult ;
24592   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24593   Dali::PixelData arg2 ;
24594   unsigned int arg3 ;
24595   unsigned int arg4 ;
24596   unsigned int arg5 ;
24597   unsigned int arg6 ;
24598   unsigned int arg7 ;
24599   unsigned int arg8 ;
24600   Dali::PixelData *argp2 ;
24601   bool result;
24602
24603   arg1 = (Dali::Texture *)jarg1;
24604   argp2 = (Dali::PixelData *)jarg2;
24605   if (!argp2) {
24606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24607     return 0;
24608   }
24609   arg2 = *argp2;
24610   arg3 = (unsigned int)jarg3;
24611   arg4 = (unsigned int)jarg4;
24612   arg5 = (unsigned int)jarg5;
24613   arg6 = (unsigned int)jarg6;
24614   arg7 = (unsigned int)jarg7;
24615   arg8 = (unsigned int)jarg8;
24616   {
24617     try {
24618       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24619     } catch (std::out_of_range& e) {
24620       {
24621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24622       };
24623     } catch (std::exception& e) {
24624       {
24625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24626       };
24627     } catch (Dali::DaliException e) {
24628       {
24629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24630       };
24631     } catch (...) {
24632       {
24633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24634       };
24635     }
24636   }
24637
24638   jresult = result;
24639   return jresult;
24640 }
24641
24642
24643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24644   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24645
24646   arg1 = (Dali::Texture *)jarg1;
24647   {
24648     try {
24649       (arg1)->GenerateMipmaps();
24650     } catch (std::out_of_range& e) {
24651       {
24652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24653       };
24654     } catch (std::exception& e) {
24655       {
24656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24657       };
24658     } catch (Dali::DaliException e) {
24659       {
24660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24661       };
24662     } catch (...) {
24663       {
24664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24665       };
24666     }
24667   }
24668
24669 }
24670
24671
24672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24673   unsigned int jresult ;
24674   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24675   unsigned int result;
24676
24677   arg1 = (Dali::Texture *)jarg1;
24678   {
24679     try {
24680       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24681     } catch (std::out_of_range& e) {
24682       {
24683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24684       };
24685     } catch (std::exception& e) {
24686       {
24687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24688       };
24689     } catch (Dali::DaliException e) {
24690       {
24691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24692       };
24693     } catch (...) {
24694       {
24695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24696       };
24697     }
24698   }
24699
24700   jresult = result;
24701   return jresult;
24702 }
24703
24704
24705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24706   unsigned int jresult ;
24707   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24708   unsigned int result;
24709
24710   arg1 = (Dali::Texture *)jarg1;
24711   {
24712     try {
24713       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24714     } catch (std::out_of_range& e) {
24715       {
24716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24717       };
24718     } catch (std::exception& e) {
24719       {
24720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24721       };
24722     } catch (Dali::DaliException e) {
24723       {
24724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24725       };
24726     } catch (...) {
24727       {
24728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24729       };
24730     }
24731   }
24732
24733   jresult = result;
24734   return jresult;
24735 }
24736
24737
24738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24739   void * jresult ;
24740   Dali::Sampler result;
24741
24742   {
24743     try {
24744       result = Dali::Sampler::New();
24745     } catch (std::out_of_range& e) {
24746       {
24747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24748       };
24749     } catch (std::exception& e) {
24750       {
24751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24752       };
24753     } catch (Dali::DaliException e) {
24754       {
24755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24756       };
24757     } catch (...) {
24758       {
24759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24760       };
24761     }
24762   }
24763
24764   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24765   return jresult;
24766 }
24767
24768
24769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24770   void * jresult ;
24771   Dali::Sampler *result = 0 ;
24772
24773   {
24774     try {
24775       result = (Dali::Sampler *)new Dali::Sampler();
24776     } catch (std::out_of_range& e) {
24777       {
24778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24779       };
24780     } catch (std::exception& e) {
24781       {
24782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24783       };
24784     } catch (Dali::DaliException e) {
24785       {
24786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24787       };
24788     } catch (...) {
24789       {
24790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24791       };
24792     }
24793   }
24794
24795   jresult = (void *)result;
24796   return jresult;
24797 }
24798
24799
24800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24801   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24802
24803   arg1 = (Dali::Sampler *)jarg1;
24804   {
24805     try {
24806       delete arg1;
24807     } catch (std::out_of_range& e) {
24808       {
24809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24810       };
24811     } catch (std::exception& e) {
24812       {
24813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24814       };
24815     } catch (Dali::DaliException e) {
24816       {
24817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24818       };
24819     } catch (...) {
24820       {
24821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24822       };
24823     }
24824   }
24825
24826 }
24827
24828
24829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24830   void * jresult ;
24831   Dali::Sampler *arg1 = 0 ;
24832   Dali::Sampler *result = 0 ;
24833
24834   arg1 = (Dali::Sampler *)jarg1;
24835   if (!arg1) {
24836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24837     return 0;
24838   }
24839   {
24840     try {
24841       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24842     } catch (std::out_of_range& e) {
24843       {
24844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24845       };
24846     } catch (std::exception& e) {
24847       {
24848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24849       };
24850     } catch (Dali::DaliException e) {
24851       {
24852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24853       };
24854     } catch (...) {
24855       {
24856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24857       };
24858     }
24859   }
24860
24861   jresult = (void *)result;
24862   return jresult;
24863 }
24864
24865
24866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24867   void * jresult ;
24868   Dali::BaseHandle arg1 ;
24869   Dali::BaseHandle *argp1 ;
24870   Dali::Sampler result;
24871
24872   argp1 = (Dali::BaseHandle *)jarg1;
24873   if (!argp1) {
24874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24875     return 0;
24876   }
24877   arg1 = *argp1;
24878   {
24879     try {
24880       result = Dali::Sampler::DownCast(arg1);
24881     } catch (std::out_of_range& e) {
24882       {
24883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24884       };
24885     } catch (std::exception& e) {
24886       {
24887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24888       };
24889     } catch (Dali::DaliException e) {
24890       {
24891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24892       };
24893     } catch (...) {
24894       {
24895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24896       };
24897     }
24898   }
24899
24900   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24901   return jresult;
24902 }
24903
24904
24905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24906   void * jresult ;
24907   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24908   Dali::Sampler *arg2 = 0 ;
24909   Dali::Sampler *result = 0 ;
24910
24911   arg1 = (Dali::Sampler *)jarg1;
24912   arg2 = (Dali::Sampler *)jarg2;
24913   if (!arg2) {
24914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24915     return 0;
24916   }
24917   {
24918     try {
24919       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24920     } catch (std::out_of_range& e) {
24921       {
24922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24923       };
24924     } catch (std::exception& e) {
24925       {
24926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24927       };
24928     } catch (Dali::DaliException e) {
24929       {
24930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24931       };
24932     } catch (...) {
24933       {
24934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24935       };
24936     }
24937   }
24938
24939   jresult = (void *)result;
24940   return jresult;
24941 }
24942
24943
24944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24945   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24946   Dali::FilterMode::Type arg2 ;
24947   Dali::FilterMode::Type arg3 ;
24948
24949   arg1 = (Dali::Sampler *)jarg1;
24950   arg2 = (Dali::FilterMode::Type)jarg2;
24951   arg3 = (Dali::FilterMode::Type)jarg3;
24952   {
24953     try {
24954       (arg1)->SetFilterMode(arg2,arg3);
24955     } catch (std::out_of_range& e) {
24956       {
24957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24958       };
24959     } catch (std::exception& e) {
24960       {
24961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24962       };
24963     } catch (Dali::DaliException e) {
24964       {
24965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24966       };
24967     } catch (...) {
24968       {
24969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24970       };
24971     }
24972   }
24973
24974 }
24975
24976
24977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24978   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24979   Dali::WrapMode::Type arg2 ;
24980   Dali::WrapMode::Type arg3 ;
24981
24982   arg1 = (Dali::Sampler *)jarg1;
24983   arg2 = (Dali::WrapMode::Type)jarg2;
24984   arg3 = (Dali::WrapMode::Type)jarg3;
24985   {
24986     try {
24987       (arg1)->SetWrapMode(arg2,arg3);
24988     } catch (std::out_of_range& e) {
24989       {
24990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24991       };
24992     } catch (std::exception& e) {
24993       {
24994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24995       };
24996     } catch (Dali::DaliException e) {
24997       {
24998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24999       };
25000     } catch (...) {
25001       {
25002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25003       };
25004     }
25005   }
25006
25007 }
25008
25009
25010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25011   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25012   Dali::WrapMode::Type arg2 ;
25013   Dali::WrapMode::Type arg3 ;
25014   Dali::WrapMode::Type arg4 ;
25015
25016   arg1 = (Dali::Sampler *)jarg1;
25017   arg2 = (Dali::WrapMode::Type)jarg2;
25018   arg3 = (Dali::WrapMode::Type)jarg3;
25019   arg4 = (Dali::WrapMode::Type)jarg4;
25020   {
25021     try {
25022       (arg1)->SetWrapMode(arg2,arg3,arg4);
25023     } catch (std::out_of_range& e) {
25024       {
25025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25026       };
25027     } catch (std::exception& e) {
25028       {
25029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25030       };
25031     } catch (Dali::DaliException e) {
25032       {
25033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25034       };
25035     } catch (...) {
25036       {
25037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25038       };
25039     }
25040   }
25041
25042 }
25043
25044
25045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25046   void * jresult ;
25047   Dali::TextureSet result;
25048
25049   {
25050     try {
25051       result = Dali::TextureSet::New();
25052     } catch (std::out_of_range& e) {
25053       {
25054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25055       };
25056     } catch (std::exception& e) {
25057       {
25058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25059       };
25060     } catch (Dali::DaliException e) {
25061       {
25062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25063       };
25064     } catch (...) {
25065       {
25066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25067       };
25068     }
25069   }
25070
25071   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25072   return jresult;
25073 }
25074
25075
25076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25077   void * jresult ;
25078   Dali::TextureSet *result = 0 ;
25079
25080   {
25081     try {
25082       result = (Dali::TextureSet *)new Dali::TextureSet();
25083     } catch (std::out_of_range& e) {
25084       {
25085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25086       };
25087     } catch (std::exception& e) {
25088       {
25089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25090       };
25091     } catch (Dali::DaliException e) {
25092       {
25093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25094       };
25095     } catch (...) {
25096       {
25097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25098       };
25099     }
25100   }
25101
25102   jresult = (void *)result;
25103   return jresult;
25104 }
25105
25106
25107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25108   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25109
25110   arg1 = (Dali::TextureSet *)jarg1;
25111   {
25112     try {
25113       delete arg1;
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 (Dali::DaliException e) {
25123       {
25124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25125       };
25126     } catch (...) {
25127       {
25128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25129       };
25130     }
25131   }
25132
25133 }
25134
25135
25136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25137   void * jresult ;
25138   Dali::TextureSet *arg1 = 0 ;
25139   Dali::TextureSet *result = 0 ;
25140
25141   arg1 = (Dali::TextureSet *)jarg1;
25142   if (!arg1) {
25143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25144     return 0;
25145   }
25146   {
25147     try {
25148       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25149     } catch (std::out_of_range& e) {
25150       {
25151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25152       };
25153     } catch (std::exception& e) {
25154       {
25155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25156       };
25157     } catch (Dali::DaliException e) {
25158       {
25159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25160       };
25161     } catch (...) {
25162       {
25163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25164       };
25165     }
25166   }
25167
25168   jresult = (void *)result;
25169   return jresult;
25170 }
25171
25172
25173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25174   void * jresult ;
25175   Dali::BaseHandle arg1 ;
25176   Dali::BaseHandle *argp1 ;
25177   Dali::TextureSet result;
25178
25179   argp1 = (Dali::BaseHandle *)jarg1;
25180   if (!argp1) {
25181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25182     return 0;
25183   }
25184   arg1 = *argp1;
25185   {
25186     try {
25187       result = Dali::TextureSet::DownCast(arg1);
25188     } catch (std::out_of_range& e) {
25189       {
25190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25191       };
25192     } catch (std::exception& e) {
25193       {
25194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25195       };
25196     } catch (Dali::DaliException e) {
25197       {
25198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25199       };
25200     } catch (...) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25203       };
25204     }
25205   }
25206
25207   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25208   return jresult;
25209 }
25210
25211
25212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25213   void * jresult ;
25214   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25215   Dali::TextureSet *arg2 = 0 ;
25216   Dali::TextureSet *result = 0 ;
25217
25218   arg1 = (Dali::TextureSet *)jarg1;
25219   arg2 = (Dali::TextureSet *)jarg2;
25220   if (!arg2) {
25221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25222     return 0;
25223   }
25224   {
25225     try {
25226       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25227     } catch (std::out_of_range& e) {
25228       {
25229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25230       };
25231     } catch (std::exception& e) {
25232       {
25233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25234       };
25235     } catch (Dali::DaliException e) {
25236       {
25237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25238       };
25239     } catch (...) {
25240       {
25241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25242       };
25243     }
25244   }
25245
25246   jresult = (void *)result;
25247   return jresult;
25248 }
25249
25250
25251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25252   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25253   size_t arg2 ;
25254   Dali::Texture arg3 ;
25255   Dali::Texture *argp3 ;
25256
25257   arg1 = (Dali::TextureSet *)jarg1;
25258   arg2 = (size_t)jarg2;
25259   argp3 = (Dali::Texture *)jarg3;
25260   if (!argp3) {
25261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25262     return ;
25263   }
25264   arg3 = *argp3;
25265   {
25266     try {
25267       (arg1)->SetTexture(arg2,arg3);
25268     } catch (std::out_of_range& e) {
25269       {
25270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25271       };
25272     } catch (std::exception& e) {
25273       {
25274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25275       };
25276     } catch (Dali::DaliException e) {
25277       {
25278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25279       };
25280     } catch (...) {
25281       {
25282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25283       };
25284     }
25285   }
25286
25287 }
25288
25289
25290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25291   void * jresult ;
25292   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25293   size_t arg2 ;
25294   Dali::Texture result;
25295
25296   arg1 = (Dali::TextureSet *)jarg1;
25297   arg2 = (size_t)jarg2;
25298   {
25299     try {
25300       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25301     } catch (std::out_of_range& e) {
25302       {
25303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25304       };
25305     } catch (std::exception& e) {
25306       {
25307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25308       };
25309     } catch (Dali::DaliException e) {
25310       {
25311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25312       };
25313     } catch (...) {
25314       {
25315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25316       };
25317     }
25318   }
25319
25320   jresult = new Dali::Texture((const Dali::Texture &)result);
25321   return jresult;
25322 }
25323
25324
25325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25326   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25327   size_t arg2 ;
25328   Dali::Sampler arg3 ;
25329   Dali::Sampler *argp3 ;
25330
25331   arg1 = (Dali::TextureSet *)jarg1;
25332   arg2 = (size_t)jarg2;
25333   argp3 = (Dali::Sampler *)jarg3;
25334   if (!argp3) {
25335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25336     return ;
25337   }
25338   arg3 = *argp3;
25339   {
25340     try {
25341       (arg1)->SetSampler(arg2,arg3);
25342     } catch (std::out_of_range& e) {
25343       {
25344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25345       };
25346     } catch (std::exception& e) {
25347       {
25348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25349       };
25350     } catch (Dali::DaliException e) {
25351       {
25352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25353       };
25354     } catch (...) {
25355       {
25356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25357       };
25358     }
25359   }
25360
25361 }
25362
25363
25364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25365   void * jresult ;
25366   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25367   size_t arg2 ;
25368   Dali::Sampler result;
25369
25370   arg1 = (Dali::TextureSet *)jarg1;
25371   arg2 = (size_t)jarg2;
25372   {
25373     try {
25374       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25375     } catch (std::out_of_range& e) {
25376       {
25377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25378       };
25379     } catch (std::exception& e) {
25380       {
25381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25382       };
25383     } catch (Dali::DaliException e) {
25384       {
25385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25386       };
25387     } catch (...) {
25388       {
25389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25390       };
25391     }
25392   }
25393
25394   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25395   return jresult;
25396 }
25397
25398
25399 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25400   unsigned long jresult ;
25401   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25402   size_t result;
25403
25404   arg1 = (Dali::TextureSet *)jarg1;
25405   {
25406     try {
25407       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25408     } catch (std::out_of_range& e) {
25409       {
25410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25411       };
25412     } catch (std::exception& e) {
25413       {
25414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25415       };
25416     } catch (Dali::DaliException e) {
25417       {
25418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25419       };
25420     } catch (...) {
25421       {
25422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25423       };
25424     }
25425   }
25426
25427   jresult = (unsigned long)result;
25428   return jresult;
25429 }
25430
25431
25432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25433   void * jresult ;
25434   Dali::Property::Map *arg1 = 0 ;
25435   Dali::PropertyBuffer result;
25436
25437   arg1 = (Dali::Property::Map *)jarg1;
25438   if (!arg1) {
25439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25440     return 0;
25441   }
25442   {
25443     try {
25444       result = Dali::PropertyBuffer::New(*arg1);
25445     } catch (std::out_of_range& e) {
25446       {
25447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25448       };
25449     } catch (std::exception& e) {
25450       {
25451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25452       };
25453     } catch (Dali::DaliException e) {
25454       {
25455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25456       };
25457     } catch (...) {
25458       {
25459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25460       };
25461     }
25462   }
25463
25464   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25465   return jresult;
25466 }
25467
25468
25469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25470   void * jresult ;
25471   Dali::PropertyBuffer *result = 0 ;
25472
25473   {
25474     try {
25475       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25476     } catch (std::out_of_range& e) {
25477       {
25478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25479       };
25480     } catch (std::exception& e) {
25481       {
25482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25483       };
25484     } catch (Dali::DaliException e) {
25485       {
25486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25487       };
25488     } catch (...) {
25489       {
25490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25491       };
25492     }
25493   }
25494
25495   jresult = (void *)result;
25496   return jresult;
25497 }
25498
25499
25500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25501   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25502
25503   arg1 = (Dali::PropertyBuffer *)jarg1;
25504   {
25505     try {
25506       delete arg1;
25507     } catch (std::out_of_range& e) {
25508       {
25509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25510       };
25511     } catch (std::exception& e) {
25512       {
25513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25514       };
25515     } catch (Dali::DaliException e) {
25516       {
25517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25518       };
25519     } catch (...) {
25520       {
25521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25522       };
25523     }
25524   }
25525
25526 }
25527
25528
25529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25530   void * jresult ;
25531   Dali::PropertyBuffer *arg1 = 0 ;
25532   Dali::PropertyBuffer *result = 0 ;
25533
25534   arg1 = (Dali::PropertyBuffer *)jarg1;
25535   if (!arg1) {
25536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25537     return 0;
25538   }
25539   {
25540     try {
25541       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25542     } catch (std::out_of_range& e) {
25543       {
25544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25545       };
25546     } catch (std::exception& e) {
25547       {
25548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25549       };
25550     } catch (Dali::DaliException e) {
25551       {
25552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25553       };
25554     } catch (...) {
25555       {
25556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25557       };
25558     }
25559   }
25560
25561   jresult = (void *)result;
25562   return jresult;
25563 }
25564
25565
25566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25567   void * jresult ;
25568   Dali::BaseHandle arg1 ;
25569   Dali::BaseHandle *argp1 ;
25570   Dali::PropertyBuffer result;
25571
25572   argp1 = (Dali::BaseHandle *)jarg1;
25573   if (!argp1) {
25574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25575     return 0;
25576   }
25577   arg1 = *argp1;
25578   {
25579     try {
25580       result = Dali::PropertyBuffer::DownCast(arg1);
25581     } catch (std::out_of_range& e) {
25582       {
25583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25584       };
25585     } catch (std::exception& e) {
25586       {
25587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25588       };
25589     } catch (Dali::DaliException e) {
25590       {
25591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25592       };
25593     } catch (...) {
25594       {
25595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25596       };
25597     }
25598   }
25599
25600   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25601   return jresult;
25602 }
25603
25604
25605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25606   void * jresult ;
25607   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25608   Dali::PropertyBuffer *arg2 = 0 ;
25609   Dali::PropertyBuffer *result = 0 ;
25610
25611   arg1 = (Dali::PropertyBuffer *)jarg1;
25612   arg2 = (Dali::PropertyBuffer *)jarg2;
25613   if (!arg2) {
25614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25615     return 0;
25616   }
25617   {
25618     try {
25619       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25620     } catch (std::out_of_range& e) {
25621       {
25622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25623       };
25624     } catch (std::exception& e) {
25625       {
25626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25627       };
25628     } catch (Dali::DaliException e) {
25629       {
25630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25631       };
25632     } catch (...) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25635       };
25636     }
25637   }
25638
25639   jresult = (void *)result;
25640   return jresult;
25641 }
25642
25643
25644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25645   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25646   void *arg2 = (void *) 0 ;
25647   std::size_t arg3 ;
25648
25649   arg1 = (Dali::PropertyBuffer *)jarg1;
25650   arg2 = jarg2;
25651   arg3 = (std::size_t)jarg3;
25652   {
25653     try {
25654       (arg1)->SetData((void const *)arg2,arg3);
25655     } catch (std::out_of_range& e) {
25656       {
25657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25658       };
25659     } catch (std::exception& e) {
25660       {
25661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25662       };
25663     } catch (Dali::DaliException e) {
25664       {
25665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25666       };
25667     } catch (...) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25670       };
25671     }
25672   }
25673
25674 }
25675
25676
25677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25678   unsigned long jresult ;
25679   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25680   std::size_t result;
25681
25682   arg1 = (Dali::PropertyBuffer *)jarg1;
25683   {
25684     try {
25685       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25686     } catch (std::out_of_range& e) {
25687       {
25688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25689       };
25690     } catch (std::exception& e) {
25691       {
25692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25693       };
25694     } catch (Dali::DaliException e) {
25695       {
25696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25697       };
25698     } catch (...) {
25699       {
25700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25701       };
25702     }
25703   }
25704
25705   jresult = (unsigned long)result;
25706   return jresult;
25707 }
25708
25709
25710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25711   void * jresult ;
25712   Dali::Geometry result;
25713
25714   {
25715     try {
25716       result = Dali::Geometry::New();
25717     } catch (std::out_of_range& e) {
25718       {
25719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25720       };
25721     } catch (std::exception& e) {
25722       {
25723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25724       };
25725     } catch (Dali::DaliException e) {
25726       {
25727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25728       };
25729     } catch (...) {
25730       {
25731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25732       };
25733     }
25734   }
25735
25736   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25737   return jresult;
25738 }
25739
25740
25741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25742   void * jresult ;
25743   Dali::Geometry *result = 0 ;
25744
25745   {
25746     try {
25747       result = (Dali::Geometry *)new Dali::Geometry();
25748     } catch (std::out_of_range& e) {
25749       {
25750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25751       };
25752     } catch (std::exception& e) {
25753       {
25754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (Dali::DaliException e) {
25757       {
25758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25759       };
25760     } catch (...) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25763       };
25764     }
25765   }
25766
25767   jresult = (void *)result;
25768   return jresult;
25769 }
25770
25771
25772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25773   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25774
25775   arg1 = (Dali::Geometry *)jarg1;
25776   {
25777     try {
25778       delete arg1;
25779     } catch (std::out_of_range& e) {
25780       {
25781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25782       };
25783     } catch (std::exception& e) {
25784       {
25785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25786       };
25787     } catch (Dali::DaliException e) {
25788       {
25789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25790       };
25791     } catch (...) {
25792       {
25793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25794       };
25795     }
25796   }
25797
25798 }
25799
25800
25801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25802   void * jresult ;
25803   Dali::Geometry *arg1 = 0 ;
25804   Dali::Geometry *result = 0 ;
25805
25806   arg1 = (Dali::Geometry *)jarg1;
25807   if (!arg1) {
25808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25809     return 0;
25810   }
25811   {
25812     try {
25813       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25814     } catch (std::out_of_range& e) {
25815       {
25816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25817       };
25818     } catch (std::exception& e) {
25819       {
25820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25821       };
25822     } catch (Dali::DaliException e) {
25823       {
25824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25825       };
25826     } catch (...) {
25827       {
25828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25829       };
25830     }
25831   }
25832
25833   jresult = (void *)result;
25834   return jresult;
25835 }
25836
25837
25838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25839   void * jresult ;
25840   Dali::BaseHandle arg1 ;
25841   Dali::BaseHandle *argp1 ;
25842   Dali::Geometry result;
25843
25844   argp1 = (Dali::BaseHandle *)jarg1;
25845   if (!argp1) {
25846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25847     return 0;
25848   }
25849   arg1 = *argp1;
25850   {
25851     try {
25852       result = Dali::Geometry::DownCast(arg1);
25853     } catch (std::out_of_range& e) {
25854       {
25855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25856       };
25857     } catch (std::exception& e) {
25858       {
25859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25860       };
25861     } catch (Dali::DaliException e) {
25862       {
25863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25864       };
25865     } catch (...) {
25866       {
25867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25868       };
25869     }
25870   }
25871
25872   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25873   return jresult;
25874 }
25875
25876
25877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25878   void * jresult ;
25879   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25880   Dali::Geometry *arg2 = 0 ;
25881   Dali::Geometry *result = 0 ;
25882
25883   arg1 = (Dali::Geometry *)jarg1;
25884   arg2 = (Dali::Geometry *)jarg2;
25885   if (!arg2) {
25886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25887     return 0;
25888   }
25889   {
25890     try {
25891       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25892     } catch (std::out_of_range& e) {
25893       {
25894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25895       };
25896     } catch (std::exception& e) {
25897       {
25898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (Dali::DaliException e) {
25901       {
25902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25903       };
25904     } catch (...) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25907       };
25908     }
25909   }
25910
25911   jresult = (void *)result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25917   unsigned long jresult ;
25918   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25919   Dali::PropertyBuffer *arg2 = 0 ;
25920   std::size_t result;
25921
25922   arg1 = (Dali::Geometry *)jarg1;
25923   arg2 = (Dali::PropertyBuffer *)jarg2;
25924   if (!arg2) {
25925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25926     return 0;
25927   }
25928   {
25929     try {
25930       result = (arg1)->AddVertexBuffer(*arg2);
25931     } catch (std::out_of_range& e) {
25932       {
25933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25934       };
25935     } catch (std::exception& e) {
25936       {
25937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25938       };
25939     } catch (Dali::DaliException e) {
25940       {
25941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25942       };
25943     } catch (...) {
25944       {
25945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25946       };
25947     }
25948   }
25949
25950   jresult = (unsigned long)result;
25951   return jresult;
25952 }
25953
25954
25955 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25956   unsigned long jresult ;
25957   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25958   std::size_t result;
25959
25960   arg1 = (Dali::Geometry *)jarg1;
25961   {
25962     try {
25963       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25964     } catch (std::out_of_range& e) {
25965       {
25966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25967       };
25968     } catch (std::exception& e) {
25969       {
25970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25971       };
25972     } catch (Dali::DaliException e) {
25973       {
25974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25975       };
25976     } catch (...) {
25977       {
25978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25979       };
25980     }
25981   }
25982
25983   jresult = (unsigned long)result;
25984   return jresult;
25985 }
25986
25987
25988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25989   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25990   std::size_t arg2 ;
25991
25992   arg1 = (Dali::Geometry *)jarg1;
25993   arg2 = (std::size_t)jarg2;
25994   {
25995     try {
25996       (arg1)->RemoveVertexBuffer(arg2);
25997     } catch (std::out_of_range& e) {
25998       {
25999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26000       };
26001     } catch (std::exception& e) {
26002       {
26003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26004       };
26005     } catch (Dali::DaliException e) {
26006       {
26007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26008       };
26009     } catch (...) {
26010       {
26011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26012       };
26013     }
26014   }
26015
26016 }
26017
26018
26019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26020   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26021   unsigned short *arg2 = (unsigned short *) 0 ;
26022   size_t arg3 ;
26023
26024   arg1 = (Dali::Geometry *)jarg1;
26025   arg2 = jarg2;
26026   arg3 = (size_t)jarg3;
26027   {
26028     try {
26029       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26030     } catch (std::out_of_range& e) {
26031       {
26032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26033       };
26034     } catch (std::exception& e) {
26035       {
26036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26037       };
26038     } catch (Dali::DaliException e) {
26039       {
26040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26041       };
26042     } catch (...) {
26043       {
26044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26045       };
26046     }
26047   }
26048
26049
26050
26051 }
26052
26053
26054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26055   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26056   Dali::Geometry::Type arg2 ;
26057
26058   arg1 = (Dali::Geometry *)jarg1;
26059   arg2 = (Dali::Geometry::Type)jarg2;
26060   {
26061     try {
26062       (arg1)->SetType(arg2);
26063     } catch (std::out_of_range& e) {
26064       {
26065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26066       };
26067     } catch (std::exception& e) {
26068       {
26069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26070       };
26071     } catch (Dali::DaliException e) {
26072       {
26073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26074       };
26075     } catch (...) {
26076       {
26077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26078       };
26079     }
26080   }
26081
26082 }
26083
26084
26085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26086   int jresult ;
26087   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26088   Dali::Geometry::Type result;
26089
26090   arg1 = (Dali::Geometry *)jarg1;
26091   {
26092     try {
26093       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26094     } catch (std::out_of_range& e) {
26095       {
26096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26097       };
26098     } catch (std::exception& e) {
26099       {
26100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26101       };
26102     } catch (Dali::DaliException e) {
26103       {
26104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26105       };
26106     } catch (...) {
26107       {
26108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26109       };
26110     }
26111   }
26112
26113   jresult = (int)result;
26114   return jresult;
26115 }
26116
26117
26118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26119   void * jresult ;
26120   Dali::Shader::Hint *result = 0 ;
26121
26122   {
26123     try {
26124       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26125     } catch (std::out_of_range& e) {
26126       {
26127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26128       };
26129     } catch (std::exception& e) {
26130       {
26131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26132       };
26133     } catch (Dali::DaliException e) {
26134       {
26135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26136       };
26137     } catch (...) {
26138       {
26139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26140       };
26141     }
26142   }
26143
26144   jresult = (void *)result;
26145   return jresult;
26146 }
26147
26148
26149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26150   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26151
26152   arg1 = (Dali::Shader::Hint *)jarg1;
26153   {
26154     try {
26155       delete arg1;
26156     } catch (std::out_of_range& e) {
26157       {
26158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26159       };
26160     } catch (std::exception& e) {
26161       {
26162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26163       };
26164     } catch (Dali::DaliException e) {
26165       {
26166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26167       };
26168     } catch (...) {
26169       {
26170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26171       };
26172     }
26173   }
26174
26175 }
26176
26177
26178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26179   int jresult ;
26180   int result;
26181
26182   result = (int)Dali::Shader::Property::PROGRAM;
26183   jresult = (int)result;
26184   return jresult;
26185 }
26186
26187
26188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26189   void * jresult ;
26190   Dali::Shader::Property *result = 0 ;
26191
26192   {
26193     try {
26194       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26195     } catch (std::out_of_range& e) {
26196       {
26197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26198       };
26199     } catch (std::exception& e) {
26200       {
26201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26202       };
26203     } catch (Dali::DaliException e) {
26204       {
26205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26206       };
26207     } catch (...) {
26208       {
26209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26210       };
26211     }
26212   }
26213
26214   jresult = (void *)result;
26215   return jresult;
26216 }
26217
26218
26219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26220   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26221
26222   arg1 = (Dali::Shader::Property *)jarg1;
26223   {
26224     try {
26225       delete arg1;
26226     } catch (std::out_of_range& e) {
26227       {
26228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26229       };
26230     } catch (std::exception& e) {
26231       {
26232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26233       };
26234     } catch (Dali::DaliException e) {
26235       {
26236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26237       };
26238     } catch (...) {
26239       {
26240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26241       };
26242     }
26243   }
26244
26245 }
26246
26247
26248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26249   void * jresult ;
26250   std::string *arg1 = 0 ;
26251   std::string *arg2 = 0 ;
26252   Dali::Shader::Hint::Value arg3 ;
26253   Dali::Shader result;
26254
26255   if (!jarg1) {
26256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26257     return 0;
26258   }
26259   std::string arg1_str(jarg1);
26260   arg1 = &arg1_str;
26261   if (!jarg2) {
26262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26263     return 0;
26264   }
26265   std::string arg2_str(jarg2);
26266   arg2 = &arg2_str;
26267   arg3 = (Dali::Shader::Hint::Value)jarg3;
26268   {
26269     try {
26270       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26271     } catch (std::out_of_range& e) {
26272       {
26273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26274       };
26275     } catch (std::exception& e) {
26276       {
26277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (Dali::DaliException e) {
26280       {
26281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26282       };
26283     } catch (...) {
26284       {
26285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26286       };
26287     }
26288   }
26289
26290   jresult = new Dali::Shader((const Dali::Shader &)result);
26291
26292   //argout typemap for const std::string&
26293
26294
26295   //argout typemap for const std::string&
26296
26297   return jresult;
26298 }
26299
26300
26301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26302   void * jresult ;
26303   std::string *arg1 = 0 ;
26304   std::string *arg2 = 0 ;
26305   Dali::Shader result;
26306
26307   if (!jarg1) {
26308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26309     return 0;
26310   }
26311   std::string arg1_str(jarg1);
26312   arg1 = &arg1_str;
26313   if (!jarg2) {
26314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26315     return 0;
26316   }
26317   std::string arg2_str(jarg2);
26318   arg2 = &arg2_str;
26319   {
26320     try {
26321       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*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 (Dali::DaliException e) {
26331       {
26332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26333       };
26334     } catch (...) {
26335       {
26336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26337       };
26338     }
26339   }
26340
26341   jresult = new Dali::Shader((const Dali::Shader &)result);
26342
26343   //argout typemap for const std::string&
26344
26345
26346   //argout typemap for const std::string&
26347
26348   return jresult;
26349 }
26350
26351
26352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26353   void * jresult ;
26354   Dali::Shader *result = 0 ;
26355
26356   {
26357     try {
26358       result = (Dali::Shader *)new Dali::Shader();
26359     } catch (std::out_of_range& e) {
26360       {
26361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26362       };
26363     } catch (std::exception& e) {
26364       {
26365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26366       };
26367     } catch (Dali::DaliException e) {
26368       {
26369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26370       };
26371     } catch (...) {
26372       {
26373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26374       };
26375     }
26376   }
26377
26378   jresult = (void *)result;
26379   return jresult;
26380 }
26381
26382
26383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26384   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26385
26386   arg1 = (Dali::Shader *)jarg1;
26387   {
26388     try {
26389       delete arg1;
26390     } catch (std::out_of_range& e) {
26391       {
26392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26393       };
26394     } catch (std::exception& e) {
26395       {
26396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26397       };
26398     } catch (Dali::DaliException e) {
26399       {
26400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26401       };
26402     } catch (...) {
26403       {
26404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26405       };
26406     }
26407   }
26408
26409 }
26410
26411
26412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26413   void * jresult ;
26414   Dali::Shader *arg1 = 0 ;
26415   Dali::Shader *result = 0 ;
26416
26417   arg1 = (Dali::Shader *)jarg1;
26418   if (!arg1) {
26419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26420     return 0;
26421   }
26422   {
26423     try {
26424       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26425     } catch (std::out_of_range& e) {
26426       {
26427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26428       };
26429     } catch (std::exception& e) {
26430       {
26431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26432       };
26433     } catch (Dali::DaliException e) {
26434       {
26435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26436       };
26437     } catch (...) {
26438       {
26439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26440       };
26441     }
26442   }
26443
26444   jresult = (void *)result;
26445   return jresult;
26446 }
26447
26448
26449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26450   void * jresult ;
26451   Dali::BaseHandle arg1 ;
26452   Dali::BaseHandle *argp1 ;
26453   Dali::Shader result;
26454
26455   argp1 = (Dali::BaseHandle *)jarg1;
26456   if (!argp1) {
26457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26458     return 0;
26459   }
26460   arg1 = *argp1;
26461   {
26462     try {
26463       result = Dali::Shader::DownCast(arg1);
26464     } catch (std::out_of_range& e) {
26465       {
26466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26467       };
26468     } catch (std::exception& e) {
26469       {
26470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26471       };
26472     } catch (Dali::DaliException e) {
26473       {
26474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26475       };
26476     } catch (...) {
26477       {
26478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26479       };
26480     }
26481   }
26482
26483   jresult = new Dali::Shader((const Dali::Shader &)result);
26484   return jresult;
26485 }
26486
26487
26488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26489   void * jresult ;
26490   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26491   Dali::Shader *arg2 = 0 ;
26492   Dali::Shader *result = 0 ;
26493
26494   arg1 = (Dali::Shader *)jarg1;
26495   arg2 = (Dali::Shader *)jarg2;
26496   if (!arg2) {
26497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26498     return 0;
26499   }
26500   {
26501     try {
26502       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26503     } catch (std::out_of_range& e) {
26504       {
26505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26506       };
26507     } catch (std::exception& e) {
26508       {
26509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26510       };
26511     } catch (Dali::DaliException e) {
26512       {
26513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26514       };
26515     } catch (...) {
26516       {
26517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26518       };
26519     }
26520   }
26521
26522   jresult = (void *)result;
26523   return jresult;
26524 }
26525
26526
26527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26528   int jresult ;
26529   int result;
26530
26531   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26532   jresult = (int)result;
26533   return jresult;
26534 }
26535
26536
26537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26538   int jresult ;
26539   int result;
26540
26541   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26542   jresult = (int)result;
26543   return jresult;
26544 }
26545
26546
26547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26548   int jresult ;
26549   int result;
26550
26551   result = (int)Dali::Renderer::Property::BLEND_MODE;
26552   jresult = (int)result;
26553   return jresult;
26554 }
26555
26556
26557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26558   int jresult ;
26559   int result;
26560
26561   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26562   jresult = (int)result;
26563   return jresult;
26564 }
26565
26566
26567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26568   int jresult ;
26569   int result;
26570
26571   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26572   jresult = (int)result;
26573   return jresult;
26574 }
26575
26576
26577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26578   int jresult ;
26579   int result;
26580
26581   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26582   jresult = (int)result;
26583   return jresult;
26584 }
26585
26586
26587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26588   int jresult ;
26589   int result;
26590
26591   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26592   jresult = (int)result;
26593   return jresult;
26594 }
26595
26596
26597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26598   int jresult ;
26599   int result;
26600
26601   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26602   jresult = (int)result;
26603   return jresult;
26604 }
26605
26606
26607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26608   int jresult ;
26609   int result;
26610
26611   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26612   jresult = (int)result;
26613   return jresult;
26614 }
26615
26616
26617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26618   int jresult ;
26619   int result;
26620
26621   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26622   jresult = (int)result;
26623   return jresult;
26624 }
26625
26626
26627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26628   int jresult ;
26629   int result;
26630
26631   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26632   jresult = (int)result;
26633   return jresult;
26634 }
26635
26636
26637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26638   int jresult ;
26639   int result;
26640
26641   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26642   jresult = (int)result;
26643   return jresult;
26644 }
26645
26646
26647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26648   int jresult ;
26649   int result;
26650
26651   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26652   jresult = (int)result;
26653   return jresult;
26654 }
26655
26656
26657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26658   int jresult ;
26659   int result;
26660
26661   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26662   jresult = (int)result;
26663   return jresult;
26664 }
26665
26666
26667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26668   int jresult ;
26669   int result;
26670
26671   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26672   jresult = (int)result;
26673   return jresult;
26674 }
26675
26676
26677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26678   int jresult ;
26679   int result;
26680
26681   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26682   jresult = (int)result;
26683   return jresult;
26684 }
26685
26686
26687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26688   int jresult ;
26689   int result;
26690
26691   result = (int)Dali::Renderer::Property::RENDER_MODE;
26692   jresult = (int)result;
26693   return jresult;
26694 }
26695
26696
26697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26698   int jresult ;
26699   int result;
26700
26701   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26702   jresult = (int)result;
26703   return jresult;
26704 }
26705
26706
26707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26708   int jresult ;
26709   int result;
26710
26711   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26712   jresult = (int)result;
26713   return jresult;
26714 }
26715
26716
26717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26718   int jresult ;
26719   int result;
26720
26721   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26722   jresult = (int)result;
26723   return jresult;
26724 }
26725
26726
26727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26728   int jresult ;
26729   int result;
26730
26731   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26732   jresult = (int)result;
26733   return jresult;
26734 }
26735
26736
26737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26738   int jresult ;
26739   int result;
26740
26741   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26742   jresult = (int)result;
26743   return jresult;
26744 }
26745
26746
26747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26748   int jresult ;
26749   int result;
26750
26751   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26752   jresult = (int)result;
26753   return jresult;
26754 }
26755
26756
26757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26758   int jresult ;
26759   int result;
26760
26761   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26762   jresult = (int)result;
26763   return jresult;
26764 }
26765
26766
26767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26768   void * jresult ;
26769   Dali::Renderer::Property *result = 0 ;
26770
26771   {
26772     try {
26773       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26774     } catch (std::out_of_range& e) {
26775       {
26776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26777       };
26778     } catch (std::exception& e) {
26779       {
26780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26781       };
26782     } catch (Dali::DaliException e) {
26783       {
26784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26785       };
26786     } catch (...) {
26787       {
26788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26789       };
26790     }
26791   }
26792
26793   jresult = (void *)result;
26794   return jresult;
26795 }
26796
26797
26798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26799   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26800
26801   arg1 = (Dali::Renderer::Property *)jarg1;
26802   {
26803     try {
26804       delete arg1;
26805     } catch (std::out_of_range& e) {
26806       {
26807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26808       };
26809     } catch (std::exception& e) {
26810       {
26811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26812       };
26813     } catch (Dali::DaliException e) {
26814       {
26815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26816       };
26817     } catch (...) {
26818       {
26819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26820       };
26821     }
26822   }
26823
26824 }
26825
26826
26827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26828   void * jresult ;
26829   Dali::Geometry *arg1 = 0 ;
26830   Dali::Shader *arg2 = 0 ;
26831   Dali::Renderer result;
26832
26833   arg1 = (Dali::Geometry *)jarg1;
26834   if (!arg1) {
26835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26836     return 0;
26837   }
26838   arg2 = (Dali::Shader *)jarg2;
26839   if (!arg2) {
26840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26841     return 0;
26842   }
26843   {
26844     try {
26845       result = Dali::Renderer::New(*arg1,*arg2);
26846     } catch (std::out_of_range& e) {
26847       {
26848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26849       };
26850     } catch (std::exception& e) {
26851       {
26852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26853       };
26854     } catch (Dali::DaliException e) {
26855       {
26856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26857       };
26858     } catch (...) {
26859       {
26860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26861       };
26862     }
26863   }
26864
26865   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26866   return jresult;
26867 }
26868
26869
26870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26871   void * jresult ;
26872   Dali::Renderer *result = 0 ;
26873
26874   {
26875     try {
26876       result = (Dali::Renderer *)new Dali::Renderer();
26877     } catch (std::out_of_range& e) {
26878       {
26879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26880       };
26881     } catch (std::exception& e) {
26882       {
26883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26884       };
26885     } catch (Dali::DaliException e) {
26886       {
26887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26888       };
26889     } catch (...) {
26890       {
26891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26892       };
26893     }
26894   }
26895
26896   jresult = (void *)result;
26897   return jresult;
26898 }
26899
26900
26901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26902   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26903
26904   arg1 = (Dali::Renderer *)jarg1;
26905   {
26906     try {
26907       delete arg1;
26908     } catch (std::out_of_range& e) {
26909       {
26910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26911       };
26912     } catch (std::exception& e) {
26913       {
26914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26915       };
26916     } catch (Dali::DaliException e) {
26917       {
26918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26919       };
26920     } catch (...) {
26921       {
26922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26923       };
26924     }
26925   }
26926
26927 }
26928
26929
26930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26931   void * jresult ;
26932   Dali::Renderer *arg1 = 0 ;
26933   Dali::Renderer *result = 0 ;
26934
26935   arg1 = (Dali::Renderer *)jarg1;
26936   if (!arg1) {
26937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26938     return 0;
26939   }
26940   {
26941     try {
26942       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26943     } catch (std::out_of_range& e) {
26944       {
26945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26946       };
26947     } catch (std::exception& e) {
26948       {
26949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26950       };
26951     } catch (Dali::DaliException e) {
26952       {
26953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26954       };
26955     } catch (...) {
26956       {
26957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26958       };
26959     }
26960   }
26961
26962   jresult = (void *)result;
26963   return jresult;
26964 }
26965
26966
26967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26968   void * jresult ;
26969   Dali::BaseHandle arg1 ;
26970   Dali::BaseHandle *argp1 ;
26971   Dali::Renderer result;
26972
26973   argp1 = (Dali::BaseHandle *)jarg1;
26974   if (!argp1) {
26975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26976     return 0;
26977   }
26978   arg1 = *argp1;
26979   {
26980     try {
26981       result = Dali::Renderer::DownCast(arg1);
26982     } catch (std::out_of_range& e) {
26983       {
26984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26985       };
26986     } catch (std::exception& e) {
26987       {
26988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26989       };
26990     } catch (Dali::DaliException e) {
26991       {
26992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26993       };
26994     } catch (...) {
26995       {
26996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26997       };
26998     }
26999   }
27000
27001   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27002   return jresult;
27003 }
27004
27005
27006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27007   void * jresult ;
27008   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27009   Dali::Renderer *arg2 = 0 ;
27010   Dali::Renderer *result = 0 ;
27011
27012   arg1 = (Dali::Renderer *)jarg1;
27013   arg2 = (Dali::Renderer *)jarg2;
27014   if (!arg2) {
27015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27016     return 0;
27017   }
27018   {
27019     try {
27020       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27021     } catch (std::out_of_range& e) {
27022       {
27023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27024       };
27025     } catch (std::exception& e) {
27026       {
27027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27028       };
27029     } catch (Dali::DaliException e) {
27030       {
27031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27032       };
27033     } catch (...) {
27034       {
27035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27036       };
27037     }
27038   }
27039
27040   jresult = (void *)result;
27041   return jresult;
27042 }
27043
27044
27045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27046   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27047   Dali::Geometry *arg2 = 0 ;
27048
27049   arg1 = (Dali::Renderer *)jarg1;
27050   arg2 = (Dali::Geometry *)jarg2;
27051   if (!arg2) {
27052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27053     return ;
27054   }
27055   {
27056     try {
27057       (arg1)->SetGeometry(*arg2);
27058     } catch (std::out_of_range& e) {
27059       {
27060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27061       };
27062     } catch (std::exception& e) {
27063       {
27064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27065       };
27066     } catch (Dali::DaliException e) {
27067       {
27068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27069       };
27070     } catch (...) {
27071       {
27072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27073       };
27074     }
27075   }
27076
27077 }
27078
27079
27080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27081   void * jresult ;
27082   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27083   Dali::Geometry result;
27084
27085   arg1 = (Dali::Renderer *)jarg1;
27086   {
27087     try {
27088       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27089     } catch (std::out_of_range& e) {
27090       {
27091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27092       };
27093     } catch (std::exception& e) {
27094       {
27095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27096       };
27097     } catch (Dali::DaliException e) {
27098       {
27099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27100       };
27101     } catch (...) {
27102       {
27103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27104       };
27105     }
27106   }
27107
27108   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27109   return jresult;
27110 }
27111
27112
27113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27114   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27115   int arg2 ;
27116   int arg3 ;
27117
27118   arg1 = (Dali::Renderer *)jarg1;
27119   arg2 = (int)jarg2;
27120   arg3 = (int)jarg3;
27121   {
27122     try {
27123       (arg1)->SetIndexRange(arg2,arg3);
27124     } catch (std::out_of_range& e) {
27125       {
27126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27127       };
27128     } catch (std::exception& e) {
27129       {
27130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27131       };
27132     } catch (Dali::DaliException e) {
27133       {
27134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27135       };
27136     } catch (...) {
27137       {
27138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27139       };
27140     }
27141   }
27142
27143 }
27144
27145
27146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27147   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27148   Dali::TextureSet *arg2 = 0 ;
27149
27150   arg1 = (Dali::Renderer *)jarg1;
27151   arg2 = (Dali::TextureSet *)jarg2;
27152   if (!arg2) {
27153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27154     return ;
27155   }
27156   {
27157     try {
27158       (arg1)->SetTextures(*arg2);
27159     } catch (std::out_of_range& e) {
27160       {
27161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27162       };
27163     } catch (std::exception& e) {
27164       {
27165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27166       };
27167     } catch (Dali::DaliException e) {
27168       {
27169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27170       };
27171     } catch (...) {
27172       {
27173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27174       };
27175     }
27176   }
27177
27178 }
27179
27180
27181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27182   void * jresult ;
27183   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27184   Dali::TextureSet result;
27185
27186   arg1 = (Dali::Renderer *)jarg1;
27187   {
27188     try {
27189       result = ((Dali::Renderer const *)arg1)->GetTextures();
27190     } catch (std::out_of_range& e) {
27191       {
27192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27193       };
27194     } catch (std::exception& e) {
27195       {
27196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27197       };
27198     } catch (Dali::DaliException e) {
27199       {
27200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27201       };
27202     } catch (...) {
27203       {
27204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27205       };
27206     }
27207   }
27208
27209   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27210   return jresult;
27211 }
27212
27213
27214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27215   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27216   Dali::Shader *arg2 = 0 ;
27217
27218   arg1 = (Dali::Renderer *)jarg1;
27219   arg2 = (Dali::Shader *)jarg2;
27220   if (!arg2) {
27221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27222     return ;
27223   }
27224   {
27225     try {
27226       (arg1)->SetShader(*arg2);
27227     } catch (std::out_of_range& e) {
27228       {
27229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27230       };
27231     } catch (std::exception& e) {
27232       {
27233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27234       };
27235     } catch (Dali::DaliException e) {
27236       {
27237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27238       };
27239     } catch (...) {
27240       {
27241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27242       };
27243     }
27244   }
27245
27246 }
27247
27248
27249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27250   void * jresult ;
27251   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27252   Dali::Shader result;
27253
27254   arg1 = (Dali::Renderer *)jarg1;
27255   {
27256     try {
27257       result = ((Dali::Renderer const *)arg1)->GetShader();
27258     } catch (std::out_of_range& e) {
27259       {
27260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27261       };
27262     } catch (std::exception& e) {
27263       {
27264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27265       };
27266     } catch (Dali::DaliException e) {
27267       {
27268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27269       };
27270     } catch (...) {
27271       {
27272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27273       };
27274     }
27275   }
27276
27277   jresult = new Dali::Shader((const Dali::Shader &)result);
27278   return jresult;
27279 }
27280
27281
27282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27283   void * jresult ;
27284   Dali::FrameBuffer::Attachment *result = 0 ;
27285
27286   {
27287     try {
27288       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27289     } catch (std::out_of_range& e) {
27290       {
27291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27292       };
27293     } catch (std::exception& e) {
27294       {
27295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27296       };
27297     } catch (Dali::DaliException e) {
27298       {
27299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27300       };
27301     } catch (...) {
27302       {
27303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27304       };
27305     }
27306   }
27307
27308   jresult = (void *)result;
27309   return jresult;
27310 }
27311
27312
27313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27314   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27315
27316   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27317   {
27318     try {
27319       delete arg1;
27320     } catch (std::out_of_range& e) {
27321       {
27322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27323       };
27324     } catch (std::exception& e) {
27325       {
27326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27327       };
27328     } catch (Dali::DaliException e) {
27329       {
27330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27331       };
27332     } catch (...) {
27333       {
27334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27335       };
27336     }
27337   }
27338
27339 }
27340
27341
27342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27343   void * jresult ;
27344   unsigned int arg1 ;
27345   unsigned int arg2 ;
27346   unsigned int arg3 ;
27347   Dali::FrameBuffer result;
27348
27349   arg1 = (unsigned int)jarg1;
27350   arg2 = (unsigned int)jarg2;
27351   arg3 = (unsigned int)jarg3;
27352   {
27353     try {
27354       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27355     } catch (std::out_of_range& e) {
27356       {
27357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27358       };
27359     } catch (std::exception& e) {
27360       {
27361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27362       };
27363     } catch (Dali::DaliException e) {
27364       {
27365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27366       };
27367     } catch (...) {
27368       {
27369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27370       };
27371     }
27372   }
27373
27374   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27375   return jresult;
27376 }
27377
27378
27379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27380   void * jresult ;
27381   Dali::FrameBuffer *result = 0 ;
27382
27383   {
27384     try {
27385       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27386     } catch (std::out_of_range& e) {
27387       {
27388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27389       };
27390     } catch (std::exception& e) {
27391       {
27392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27393       };
27394     } catch (Dali::DaliException e) {
27395       {
27396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27397       };
27398     } catch (...) {
27399       {
27400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27401       };
27402     }
27403   }
27404
27405   jresult = (void *)result;
27406   return jresult;
27407 }
27408
27409
27410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27411   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27412
27413   arg1 = (Dali::FrameBuffer *)jarg1;
27414   {
27415     try {
27416       delete arg1;
27417     } catch (std::out_of_range& e) {
27418       {
27419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27420       };
27421     } catch (std::exception& e) {
27422       {
27423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27424       };
27425     } catch (Dali::DaliException e) {
27426       {
27427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27428       };
27429     } catch (...) {
27430       {
27431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27432       };
27433     }
27434   }
27435
27436 }
27437
27438
27439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27440   void * jresult ;
27441   Dali::FrameBuffer *arg1 = 0 ;
27442   Dali::FrameBuffer *result = 0 ;
27443
27444   arg1 = (Dali::FrameBuffer *)jarg1;
27445   if (!arg1) {
27446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27447     return 0;
27448   }
27449   {
27450     try {
27451       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27452     } catch (std::out_of_range& e) {
27453       {
27454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27455       };
27456     } catch (std::exception& e) {
27457       {
27458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27459       };
27460     } catch (Dali::DaliException e) {
27461       {
27462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27463       };
27464     } catch (...) {
27465       {
27466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27467       };
27468     }
27469   }
27470
27471   jresult = (void *)result;
27472   return jresult;
27473 }
27474
27475
27476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27477   void * jresult ;
27478   Dali::BaseHandle arg1 ;
27479   Dali::BaseHandle *argp1 ;
27480   Dali::FrameBuffer result;
27481
27482   argp1 = (Dali::BaseHandle *)jarg1;
27483   if (!argp1) {
27484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27485     return 0;
27486   }
27487   arg1 = *argp1;
27488   {
27489     try {
27490       result = Dali::FrameBuffer::DownCast(arg1);
27491     } catch (std::out_of_range& e) {
27492       {
27493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27494       };
27495     } catch (std::exception& e) {
27496       {
27497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27498       };
27499     } catch (Dali::DaliException e) {
27500       {
27501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27502       };
27503     } catch (...) {
27504       {
27505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27506       };
27507     }
27508   }
27509
27510   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27511   return jresult;
27512 }
27513
27514
27515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27516   void * jresult ;
27517   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27518   Dali::FrameBuffer *arg2 = 0 ;
27519   Dali::FrameBuffer *result = 0 ;
27520
27521   arg1 = (Dali::FrameBuffer *)jarg1;
27522   arg2 = (Dali::FrameBuffer *)jarg2;
27523   if (!arg2) {
27524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27525     return 0;
27526   }
27527   {
27528     try {
27529       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27530     } catch (std::out_of_range& e) {
27531       {
27532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27533       };
27534     } catch (std::exception& e) {
27535       {
27536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27537       };
27538     } catch (Dali::DaliException e) {
27539       {
27540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27541       };
27542     } catch (...) {
27543       {
27544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27545       };
27546     }
27547   }
27548
27549   jresult = (void *)result;
27550   return jresult;
27551 }
27552
27553
27554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27555   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27556   Dali::Texture *arg2 = 0 ;
27557
27558   arg1 = (Dali::FrameBuffer *)jarg1;
27559   arg2 = (Dali::Texture *)jarg2;
27560   if (!arg2) {
27561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27562     return ;
27563   }
27564   {
27565     try {
27566       (arg1)->AttachColorTexture(*arg2);
27567     } catch (std::out_of_range& e) {
27568       {
27569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27570       };
27571     } catch (std::exception& e) {
27572       {
27573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27574       };
27575     } catch (Dali::DaliException e) {
27576       {
27577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27578       };
27579     } catch (...) {
27580       {
27581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27582       };
27583     }
27584   }
27585
27586 }
27587
27588
27589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27590   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27591   Dali::Texture *arg2 = 0 ;
27592   unsigned int arg3 ;
27593   unsigned int arg4 ;
27594
27595   arg1 = (Dali::FrameBuffer *)jarg1;
27596   arg2 = (Dali::Texture *)jarg2;
27597   if (!arg2) {
27598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27599     return ;
27600   }
27601   arg3 = (unsigned int)jarg3;
27602   arg4 = (unsigned int)jarg4;
27603   {
27604     try {
27605       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27606     } catch (std::out_of_range& e) {
27607       {
27608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27609       };
27610     } catch (std::exception& e) {
27611       {
27612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27613       };
27614     } catch (Dali::DaliException e) {
27615       {
27616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27617       };
27618     } catch (...) {
27619       {
27620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27621       };
27622     }
27623   }
27624
27625 }
27626
27627
27628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27629   void * jresult ;
27630   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27631   Dali::Texture result;
27632
27633   arg1 = (Dali::FrameBuffer *)jarg1;
27634   {
27635     try {
27636       result = (arg1)->GetColorTexture();
27637     } catch (std::out_of_range& e) {
27638       {
27639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27640       };
27641     } catch (std::exception& e) {
27642       {
27643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27644       };
27645     } catch (Dali::DaliException e) {
27646       {
27647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27648       };
27649     } catch (...) {
27650       {
27651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27652       };
27653     }
27654   }
27655
27656   jresult = new Dali::Texture((const Dali::Texture &)result);
27657   return jresult;
27658 }
27659
27660
27661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27662   void * jresult ;
27663   Dali::RenderTaskList *result = 0 ;
27664
27665   {
27666     try {
27667       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27668     } catch (std::out_of_range& e) {
27669       {
27670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27671       };
27672     } catch (std::exception& e) {
27673       {
27674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27675       };
27676     } catch (Dali::DaliException e) {
27677       {
27678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27679       };
27680     } catch (...) {
27681       {
27682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27683       };
27684     }
27685   }
27686
27687   jresult = (void *)result;
27688   return jresult;
27689 }
27690
27691
27692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27693   void * jresult ;
27694   Dali::BaseHandle arg1 ;
27695   Dali::BaseHandle *argp1 ;
27696   Dali::RenderTaskList result;
27697
27698   argp1 = (Dali::BaseHandle *)jarg1;
27699   if (!argp1) {
27700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27701     return 0;
27702   }
27703   arg1 = *argp1;
27704   {
27705     try {
27706       result = Dali::RenderTaskList::DownCast(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 (Dali::DaliException e) {
27716       {
27717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27718       };
27719     } catch (...) {
27720       {
27721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27722       };
27723     }
27724   }
27725
27726   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27727   return jresult;
27728 }
27729
27730
27731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27732   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27733
27734   arg1 = (Dali::RenderTaskList *)jarg1;
27735   {
27736     try {
27737       delete arg1;
27738     } catch (std::out_of_range& e) {
27739       {
27740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27741       };
27742     } catch (std::exception& e) {
27743       {
27744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27745       };
27746     } catch (Dali::DaliException e) {
27747       {
27748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27749       };
27750     } catch (...) {
27751       {
27752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27753       };
27754     }
27755   }
27756
27757 }
27758
27759
27760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27761   void * jresult ;
27762   Dali::RenderTaskList *arg1 = 0 ;
27763   Dali::RenderTaskList *result = 0 ;
27764
27765   arg1 = (Dali::RenderTaskList *)jarg1;
27766   if (!arg1) {
27767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27768     return 0;
27769   }
27770   {
27771     try {
27772       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27773     } catch (std::out_of_range& e) {
27774       {
27775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27776       };
27777     } catch (std::exception& e) {
27778       {
27779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27780       };
27781     } catch (Dali::DaliException e) {
27782       {
27783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27784       };
27785     } catch (...) {
27786       {
27787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27788       };
27789     }
27790   }
27791
27792   jresult = (void *)result;
27793   return jresult;
27794 }
27795
27796
27797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27798   void * jresult ;
27799   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27800   Dali::RenderTaskList *arg2 = 0 ;
27801   Dali::RenderTaskList *result = 0 ;
27802
27803   arg1 = (Dali::RenderTaskList *)jarg1;
27804   arg2 = (Dali::RenderTaskList *)jarg2;
27805   if (!arg2) {
27806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27807     return 0;
27808   }
27809   {
27810     try {
27811       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27812     } catch (std::out_of_range& e) {
27813       {
27814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27815       };
27816     } catch (std::exception& e) {
27817       {
27818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27819       };
27820     } catch (Dali::DaliException e) {
27821       {
27822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27823       };
27824     } catch (...) {
27825       {
27826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27827       };
27828     }
27829   }
27830
27831   jresult = (void *)result;
27832   return jresult;
27833 }
27834
27835
27836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27837   void * jresult ;
27838   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27839   Dali::RenderTask result;
27840
27841   arg1 = (Dali::RenderTaskList *)jarg1;
27842   {
27843     try {
27844       result = (arg1)->CreateTask();
27845     } catch (std::out_of_range& e) {
27846       {
27847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27848       };
27849     } catch (std::exception& e) {
27850       {
27851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27852       };
27853     } catch (Dali::DaliException e) {
27854       {
27855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27856       };
27857     } catch (...) {
27858       {
27859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27860       };
27861     }
27862   }
27863
27864   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27865   return jresult;
27866 }
27867
27868
27869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27870   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27871   Dali::RenderTask arg2 ;
27872   Dali::RenderTask *argp2 ;
27873
27874   arg1 = (Dali::RenderTaskList *)jarg1;
27875   argp2 = (Dali::RenderTask *)jarg2;
27876   if (!argp2) {
27877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27878     return ;
27879   }
27880   arg2 = *argp2;
27881   {
27882     try {
27883       (arg1)->RemoveTask(arg2);
27884     } catch (std::out_of_range& e) {
27885       {
27886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27887       };
27888     } catch (std::exception& e) {
27889       {
27890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27891       };
27892     } catch (Dali::DaliException e) {
27893       {
27894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27895       };
27896     } catch (...) {
27897       {
27898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27899       };
27900     }
27901   }
27902
27903 }
27904
27905
27906 //// ===============================================end part 1 =================
27907
27908 //// ========================= part 2 ===============================
27909
27910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27911   unsigned int jresult ;
27912   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27913   unsigned int result;
27914
27915   arg1 = (Dali::RenderTaskList *)jarg1;
27916   {
27917     try {
27918       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27919     } catch (std::out_of_range& e) {
27920       {
27921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27922       };
27923     } catch (std::exception& e) {
27924       {
27925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27926       };
27927     } catch (Dali::DaliException e) {
27928       {
27929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27930       };
27931     } catch (...) {
27932       {
27933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27934       };
27935     }
27936   }
27937
27938   jresult = result;
27939   return jresult;
27940 }
27941
27942
27943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27944   void * jresult ;
27945   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27946   unsigned int arg2 ;
27947   Dali::RenderTask result;
27948
27949   arg1 = (Dali::RenderTaskList *)jarg1;
27950   arg2 = (unsigned int)jarg2;
27951   {
27952     try {
27953       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27954     } catch (std::out_of_range& e) {
27955       {
27956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27957       };
27958     } catch (std::exception& e) {
27959       {
27960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27961       };
27962     } catch (Dali::DaliException e) {
27963       {
27964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27965       };
27966     } catch (...) {
27967       {
27968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27969       };
27970     }
27971   }
27972
27973   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27974   return jresult;
27975 }
27976
27977
27978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27979   int jresult ;
27980   int result;
27981
27982   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27983   jresult = (int)result;
27984   return jresult;
27985 }
27986
27987
27988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27989   int jresult ;
27990   int result;
27991
27992   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27993   jresult = (int)result;
27994   return jresult;
27995 }
27996
27997
27998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27999   int jresult ;
28000   int result;
28001
28002   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28003   jresult = (int)result;
28004   return jresult;
28005 }
28006
28007
28008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28009   int jresult ;
28010   int result;
28011
28012   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28013   jresult = (int)result;
28014   return jresult;
28015 }
28016
28017
28018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28019   void * jresult ;
28020   Dali::RenderTask::Property *result = 0 ;
28021
28022   {
28023     try {
28024       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28025     } catch (std::out_of_range& e) {
28026       {
28027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28028       };
28029     } catch (std::exception& e) {
28030       {
28031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28032       };
28033     } catch (Dali::DaliException e) {
28034       {
28035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28036       };
28037     } catch (...) {
28038       {
28039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28040       };
28041     }
28042   }
28043
28044   jresult = (void *)result;
28045   return jresult;
28046 }
28047
28048
28049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28050   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28051
28052   arg1 = (Dali::RenderTask::Property *)jarg1;
28053   {
28054     try {
28055       delete arg1;
28056     } catch (std::out_of_range& e) {
28057       {
28058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28059       };
28060     } catch (std::exception& e) {
28061       {
28062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28063       };
28064     } catch (Dali::DaliException e) {
28065       {
28066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28067       };
28068     } catch (...) {
28069       {
28070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28071       };
28072     }
28073   }
28074
28075 }
28076
28077
28078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28079   void * jresult ;
28080   bool (*result)(Dali::Vector2 &) = 0 ;
28081
28082   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28083   jresult = (void *)result;
28084   return jresult;
28085 }
28086
28087
28088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28089   void * jresult ;
28090   bool (*result)(Dali::Vector2 &) = 0 ;
28091
28092   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28093   jresult = (void *)result;
28094   return jresult;
28095 }
28096
28097
28098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28099   unsigned int jresult ;
28100   bool result;
28101
28102   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28103   jresult = result;
28104   return jresult;
28105 }
28106
28107
28108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28109   unsigned int jresult ;
28110   bool result;
28111
28112   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28113   jresult = result;
28114   return jresult;
28115 }
28116
28117
28118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28119   void * jresult ;
28120   Dali::Vector4 *result = 0 ;
28121
28122   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28123   jresult = (void *)result;
28124   return jresult;
28125 }
28126
28127
28128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28129   unsigned int jresult ;
28130   bool result;
28131
28132   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28133   jresult = result;
28134   return jresult;
28135 }
28136
28137
28138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28139   unsigned int jresult ;
28140   bool result;
28141
28142   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28143   jresult = result;
28144   return jresult;
28145 }
28146
28147
28148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28149   unsigned int jresult ;
28150   unsigned int result;
28151
28152   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28153   jresult = result;
28154   return jresult;
28155 }
28156
28157
28158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28159   void * jresult ;
28160   Dali::RenderTask *result = 0 ;
28161
28162   {
28163     try {
28164       result = (Dali::RenderTask *)new Dali::RenderTask();
28165     } catch (std::out_of_range& e) {
28166       {
28167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28168       };
28169     } catch (std::exception& e) {
28170       {
28171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28172       };
28173     } catch (Dali::DaliException e) {
28174       {
28175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28176       };
28177     } catch (...) {
28178       {
28179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28180       };
28181     }
28182   }
28183
28184   jresult = (void *)result;
28185   return jresult;
28186 }
28187
28188
28189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28190   void * jresult ;
28191   Dali::BaseHandle arg1 ;
28192   Dali::BaseHandle *argp1 ;
28193   Dali::RenderTask result;
28194
28195   argp1 = (Dali::BaseHandle *)jarg1;
28196   if (!argp1) {
28197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28198     return 0;
28199   }
28200   arg1 = *argp1;
28201   {
28202     try {
28203       result = Dali::RenderTask::DownCast(arg1);
28204     } catch (std::out_of_range& e) {
28205       {
28206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28207       };
28208     } catch (std::exception& e) {
28209       {
28210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28211       };
28212     } catch (Dali::DaliException e) {
28213       {
28214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28215       };
28216     } catch (...) {
28217       {
28218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28219       };
28220     }
28221   }
28222
28223   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28224   return jresult;
28225 }
28226
28227
28228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28229   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28230
28231   arg1 = (Dali::RenderTask *)jarg1;
28232   {
28233     try {
28234       delete arg1;
28235     } catch (std::out_of_range& e) {
28236       {
28237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28238       };
28239     } catch (std::exception& e) {
28240       {
28241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28242       };
28243     } catch (Dali::DaliException e) {
28244       {
28245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28246       };
28247     } catch (...) {
28248       {
28249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28250       };
28251     }
28252   }
28253
28254 }
28255
28256
28257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28258   void * jresult ;
28259   Dali::RenderTask *arg1 = 0 ;
28260   Dali::RenderTask *result = 0 ;
28261
28262   arg1 = (Dali::RenderTask *)jarg1;
28263   if (!arg1) {
28264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28265     return 0;
28266   }
28267   {
28268     try {
28269       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28270     } catch (std::out_of_range& e) {
28271       {
28272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28273       };
28274     } catch (std::exception& e) {
28275       {
28276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28277       };
28278     } catch (Dali::DaliException e) {
28279       {
28280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28281       };
28282     } catch (...) {
28283       {
28284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28285       };
28286     }
28287   }
28288
28289   jresult = (void *)result;
28290   return jresult;
28291 }
28292
28293
28294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28295   void * jresult ;
28296   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28297   Dali::RenderTask *arg2 = 0 ;
28298   Dali::RenderTask *result = 0 ;
28299
28300   arg1 = (Dali::RenderTask *)jarg1;
28301   arg2 = (Dali::RenderTask *)jarg2;
28302   if (!arg2) {
28303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28304     return 0;
28305   }
28306   {
28307     try {
28308       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28309     } catch (std::out_of_range& e) {
28310       {
28311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28312       };
28313     } catch (std::exception& e) {
28314       {
28315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28316       };
28317     } catch (Dali::DaliException e) {
28318       {
28319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28320       };
28321     } catch (...) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28324       };
28325     }
28326   }
28327
28328   jresult = (void *)result;
28329   return jresult;
28330 }
28331
28332
28333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28334   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28335   Dali::Actor arg2 ;
28336   Dali::Actor *argp2 ;
28337
28338   arg1 = (Dali::RenderTask *)jarg1;
28339   argp2 = (Dali::Actor *)jarg2;
28340   if (!argp2) {
28341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28342     return ;
28343   }
28344   arg2 = *argp2;
28345   {
28346     try {
28347       (arg1)->SetSourceActor(arg2);
28348     } catch (std::out_of_range& e) {
28349       {
28350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28351       };
28352     } catch (std::exception& e) {
28353       {
28354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28355       };
28356     } catch (Dali::DaliException e) {
28357       {
28358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28359       };
28360     } catch (...) {
28361       {
28362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28363       };
28364     }
28365   }
28366
28367 }
28368
28369
28370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28371   void * jresult ;
28372   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28373   Dali::Actor result;
28374
28375   arg1 = (Dali::RenderTask *)jarg1;
28376   {
28377     try {
28378       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28379     } catch (std::out_of_range& e) {
28380       {
28381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28382       };
28383     } catch (std::exception& e) {
28384       {
28385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28386       };
28387     } catch (Dali::DaliException e) {
28388       {
28389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28390       };
28391     } catch (...) {
28392       {
28393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28394       };
28395     }
28396   }
28397
28398   jresult = new Dali::Actor((const Dali::Actor &)result);
28399   return jresult;
28400 }
28401
28402
28403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28405   bool arg2 ;
28406
28407   arg1 = (Dali::RenderTask *)jarg1;
28408   arg2 = jarg2 ? true : false;
28409   {
28410     try {
28411       (arg1)->SetExclusive(arg2);
28412     } catch (std::out_of_range& e) {
28413       {
28414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28415       };
28416     } catch (std::exception& e) {
28417       {
28418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28419       };
28420     } catch (Dali::DaliException e) {
28421       {
28422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28423       };
28424     } catch (...) {
28425       {
28426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28427       };
28428     }
28429   }
28430
28431 }
28432
28433
28434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28435   unsigned int jresult ;
28436   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28437   bool result;
28438
28439   arg1 = (Dali::RenderTask *)jarg1;
28440   {
28441     try {
28442       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28443     } catch (std::out_of_range& e) {
28444       {
28445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28446       };
28447     } catch (std::exception& e) {
28448       {
28449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28450       };
28451     } catch (Dali::DaliException e) {
28452       {
28453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28454       };
28455     } catch (...) {
28456       {
28457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28458       };
28459     }
28460   }
28461
28462   jresult = result;
28463   return jresult;
28464 }
28465
28466
28467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28468   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28469   bool arg2 ;
28470
28471   arg1 = (Dali::RenderTask *)jarg1;
28472   arg2 = jarg2 ? true : false;
28473   {
28474     try {
28475       (arg1)->SetInputEnabled(arg2);
28476     } catch (std::out_of_range& e) {
28477       {
28478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28479       };
28480     } catch (std::exception& e) {
28481       {
28482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28483       };
28484     } catch (Dali::DaliException e) {
28485       {
28486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28487       };
28488     } catch (...) {
28489       {
28490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28491       };
28492     }
28493   }
28494
28495 }
28496
28497
28498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28499   unsigned int jresult ;
28500   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28501   bool result;
28502
28503   arg1 = (Dali::RenderTask *)jarg1;
28504   {
28505     try {
28506       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28507     } catch (std::out_of_range& e) {
28508       {
28509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28510       };
28511     } catch (std::exception& e) {
28512       {
28513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28514       };
28515     } catch (Dali::DaliException e) {
28516       {
28517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28518       };
28519     } catch (...) {
28520       {
28521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28522       };
28523     }
28524   }
28525
28526   jresult = result;
28527   return jresult;
28528 }
28529
28530
28531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28532   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28533   Dali::CameraActor arg2 ;
28534   Dali::CameraActor *argp2 ;
28535
28536   arg1 = (Dali::RenderTask *)jarg1;
28537   argp2 = (Dali::CameraActor *)jarg2;
28538   if (!argp2) {
28539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28540     return ;
28541   }
28542   arg2 = *argp2;
28543   {
28544     try {
28545       (arg1)->SetCameraActor(arg2);
28546     } catch (std::out_of_range& e) {
28547       {
28548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28549       };
28550     } catch (std::exception& e) {
28551       {
28552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28553       };
28554     } catch (Dali::DaliException e) {
28555       {
28556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28557       };
28558     } catch (...) {
28559       {
28560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28561       };
28562     }
28563   }
28564
28565 }
28566
28567
28568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28569   void * jresult ;
28570   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28571   Dali::CameraActor result;
28572
28573   arg1 = (Dali::RenderTask *)jarg1;
28574   {
28575     try {
28576       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28577     } catch (std::out_of_range& e) {
28578       {
28579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28580       };
28581     } catch (std::exception& e) {
28582       {
28583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28584       };
28585     } catch (Dali::DaliException e) {
28586       {
28587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28588       };
28589     } catch (...) {
28590       {
28591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28592       };
28593     }
28594   }
28595
28596   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28597   return jresult;
28598 }
28599
28600
28601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28602   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28603   Dali::FrameBufferImage arg2 ;
28604   Dali::FrameBufferImage *argp2 ;
28605
28606   arg1 = (Dali::RenderTask *)jarg1;
28607   argp2 = (Dali::FrameBufferImage *)jarg2;
28608   if (!argp2) {
28609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28610     return ;
28611   }
28612   arg2 = *argp2;
28613   {
28614     try {
28615       (arg1)->SetTargetFrameBuffer(arg2);
28616     } catch (std::out_of_range& e) {
28617       {
28618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28619       };
28620     } catch (std::exception& e) {
28621       {
28622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28623       };
28624     } catch (Dali::DaliException e) {
28625       {
28626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28627       };
28628     } catch (...) {
28629       {
28630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28631       };
28632     }
28633   }
28634
28635 }
28636
28637
28638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28639   void * jresult ;
28640   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28641   Dali::FrameBufferImage result;
28642
28643   arg1 = (Dali::RenderTask *)jarg1;
28644   {
28645     try {
28646       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28647     } catch (std::out_of_range& e) {
28648       {
28649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28650       };
28651     } catch (std::exception& e) {
28652       {
28653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28654       };
28655     } catch (Dali::DaliException e) {
28656       {
28657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28658       };
28659     } catch (...) {
28660       {
28661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28662       };
28663     }
28664   }
28665
28666   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28667   return jresult;
28668 }
28669
28670
28671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28672   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28673   Dali::FrameBuffer arg2 ;
28674   Dali::FrameBuffer *argp2 ;
28675
28676   arg1 = (Dali::RenderTask *)jarg1;
28677   argp2 = (Dali::FrameBuffer *)jarg2;
28678   if (!argp2) {
28679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28680     return ;
28681   }
28682   arg2 = *argp2;
28683   {
28684     try {
28685       (arg1)->SetFrameBuffer(arg2);
28686     } catch (std::out_of_range& e) {
28687       {
28688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28689       };
28690     } catch (std::exception& e) {
28691       {
28692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28693       };
28694     } catch (Dali::DaliException e) {
28695       {
28696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28697       };
28698     } catch (...) {
28699       {
28700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28701       };
28702     }
28703   }
28704
28705 }
28706
28707
28708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28709   void * jresult ;
28710   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28711   Dali::FrameBuffer result;
28712
28713   arg1 = (Dali::RenderTask *)jarg1;
28714   {
28715     try {
28716       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28717     } catch (std::out_of_range& e) {
28718       {
28719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28720       };
28721     } catch (std::exception& e) {
28722       {
28723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28724       };
28725     } catch (Dali::DaliException e) {
28726       {
28727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28728       };
28729     } catch (...) {
28730       {
28731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28732       };
28733     }
28734   }
28735
28736   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28737   return jresult;
28738 }
28739
28740
28741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28742   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28743   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28744
28745   arg1 = (Dali::RenderTask *)jarg1;
28746   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28747   {
28748     try {
28749       (arg1)->SetScreenToFrameBufferFunction(arg2);
28750     } catch (std::out_of_range& e) {
28751       {
28752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28753       };
28754     } catch (std::exception& e) {
28755       {
28756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28757       };
28758     } catch (Dali::DaliException e) {
28759       {
28760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28761       };
28762     } catch (...) {
28763       {
28764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28765       };
28766     }
28767   }
28768
28769 }
28770
28771
28772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28773   void * jresult ;
28774   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28775   Dali::RenderTask::ScreenToFrameBufferFunction result;
28776
28777   arg1 = (Dali::RenderTask *)jarg1;
28778   {
28779     try {
28780       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28781     } catch (std::out_of_range& e) {
28782       {
28783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28784       };
28785     } catch (std::exception& e) {
28786       {
28787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28788       };
28789     } catch (Dali::DaliException e) {
28790       {
28791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28792       };
28793     } catch (...) {
28794       {
28795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28796       };
28797     }
28798   }
28799
28800   jresult = (void *)result;
28801   return jresult;
28802 }
28803
28804
28805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28806   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28807   Dali::Actor arg2 ;
28808   Dali::Actor *argp2 ;
28809
28810   arg1 = (Dali::RenderTask *)jarg1;
28811   argp2 = (Dali::Actor *)jarg2;
28812   if (!argp2) {
28813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28814     return ;
28815   }
28816   arg2 = *argp2;
28817   {
28818     try {
28819       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28820     } catch (std::out_of_range& e) {
28821       {
28822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28823       };
28824     } catch (std::exception& e) {
28825       {
28826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28827       };
28828     } catch (Dali::DaliException e) {
28829       {
28830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28831       };
28832     } catch (...) {
28833       {
28834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28835       };
28836     }
28837   }
28838
28839 }
28840
28841
28842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28843   void * jresult ;
28844   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28845   Dali::Actor result;
28846
28847   arg1 = (Dali::RenderTask *)jarg1;
28848   {
28849     try {
28850       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28851     } catch (std::out_of_range& e) {
28852       {
28853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28854       };
28855     } catch (std::exception& e) {
28856       {
28857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28858       };
28859     } catch (Dali::DaliException e) {
28860       {
28861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28862       };
28863     } catch (...) {
28864       {
28865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28866       };
28867     }
28868   }
28869
28870   jresult = new Dali::Actor((const Dali::Actor &)result);
28871   return jresult;
28872 }
28873
28874
28875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28876   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28877   Dali::Vector2 arg2 ;
28878   Dali::Vector2 *argp2 ;
28879
28880   arg1 = (Dali::RenderTask *)jarg1;
28881   argp2 = (Dali::Vector2 *)jarg2;
28882   if (!argp2) {
28883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28884     return ;
28885   }
28886   arg2 = *argp2;
28887   {
28888     try {
28889       (arg1)->SetViewportPosition(arg2);
28890     } catch (std::out_of_range& e) {
28891       {
28892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28893       };
28894     } catch (std::exception& e) {
28895       {
28896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28897       };
28898     } catch (Dali::DaliException e) {
28899       {
28900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28901       };
28902     } catch (...) {
28903       {
28904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28905       };
28906     }
28907   }
28908
28909 }
28910
28911
28912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28913   void * jresult ;
28914   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28915   Dali::Vector2 result;
28916
28917   arg1 = (Dali::RenderTask *)jarg1;
28918   {
28919     try {
28920       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28921     } catch (std::out_of_range& e) {
28922       {
28923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28924       };
28925     } catch (std::exception& e) {
28926       {
28927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28928       };
28929     } catch (Dali::DaliException e) {
28930       {
28931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28932       };
28933     } catch (...) {
28934       {
28935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28936       };
28937     }
28938   }
28939
28940   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28941   return jresult;
28942 }
28943
28944
28945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28946   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28947   Dali::Vector2 arg2 ;
28948   Dali::Vector2 *argp2 ;
28949
28950   arg1 = (Dali::RenderTask *)jarg1;
28951   argp2 = (Dali::Vector2 *)jarg2;
28952   if (!argp2) {
28953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28954     return ;
28955   }
28956   arg2 = *argp2;
28957   {
28958     try {
28959       (arg1)->SetViewportSize(arg2);
28960     } catch (std::out_of_range& e) {
28961       {
28962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28963       };
28964     } catch (std::exception& e) {
28965       {
28966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28967       };
28968     } catch (Dali::DaliException e) {
28969       {
28970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28971       };
28972     } catch (...) {
28973       {
28974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28975       };
28976     }
28977   }
28978
28979 }
28980
28981
28982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28983   void * jresult ;
28984   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28985   Dali::Vector2 result;
28986
28987   arg1 = (Dali::RenderTask *)jarg1;
28988   {
28989     try {
28990       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28991     } catch (std::out_of_range& e) {
28992       {
28993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28994       };
28995     } catch (std::exception& e) {
28996       {
28997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28998       };
28999     } catch (Dali::DaliException e) {
29000       {
29001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29002       };
29003     } catch (...) {
29004       {
29005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29006       };
29007     }
29008   }
29009
29010   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29011   return jresult;
29012 }
29013
29014
29015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29016   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29017   Dali::Viewport arg2 ;
29018   Dali::Viewport *argp2 ;
29019
29020   arg1 = (Dali::RenderTask *)jarg1;
29021   argp2 = (Dali::Viewport *)jarg2;
29022   if (!argp2) {
29023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29024     return ;
29025   }
29026   arg2 = *argp2;
29027   {
29028     try {
29029       (arg1)->SetViewport(arg2);
29030     } catch (std::out_of_range& e) {
29031       {
29032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29033       };
29034     } catch (std::exception& e) {
29035       {
29036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29037       };
29038     } catch (Dali::DaliException e) {
29039       {
29040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29041       };
29042     } catch (...) {
29043       {
29044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29045       };
29046     }
29047   }
29048
29049 }
29050
29051
29052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29053   void * jresult ;
29054   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29055   Dali::Viewport result;
29056
29057   arg1 = (Dali::RenderTask *)jarg1;
29058   {
29059     try {
29060       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29061     } catch (std::out_of_range& e) {
29062       {
29063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29064       };
29065     } catch (std::exception& e) {
29066       {
29067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29068       };
29069     } catch (Dali::DaliException e) {
29070       {
29071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29072       };
29073     } catch (...) {
29074       {
29075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29076       };
29077     }
29078   }
29079
29080   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29081   return jresult;
29082 }
29083
29084
29085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29086   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29087   Dali::Vector4 *arg2 = 0 ;
29088
29089   arg1 = (Dali::RenderTask *)jarg1;
29090   arg2 = (Dali::Vector4 *)jarg2;
29091   if (!arg2) {
29092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29093     return ;
29094   }
29095   {
29096     try {
29097       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29098     } catch (std::out_of_range& e) {
29099       {
29100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29101       };
29102     } catch (std::exception& e) {
29103       {
29104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29105       };
29106     } catch (Dali::DaliException e) {
29107       {
29108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29109       };
29110     } catch (...) {
29111       {
29112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29113       };
29114     }
29115   }
29116
29117 }
29118
29119
29120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29121   void * jresult ;
29122   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29123   Dali::Vector4 result;
29124
29125   arg1 = (Dali::RenderTask *)jarg1;
29126   {
29127     try {
29128       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29129     } catch (std::out_of_range& e) {
29130       {
29131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29132       };
29133     } catch (std::exception& e) {
29134       {
29135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29136       };
29137     } catch (Dali::DaliException e) {
29138       {
29139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29140       };
29141     } catch (...) {
29142       {
29143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29144       };
29145     }
29146   }
29147
29148   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29149   return jresult;
29150 }
29151
29152
29153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29154   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29155   bool arg2 ;
29156
29157   arg1 = (Dali::RenderTask *)jarg1;
29158   arg2 = jarg2 ? true : false;
29159   {
29160     try {
29161       (arg1)->SetClearEnabled(arg2);
29162     } catch (std::out_of_range& e) {
29163       {
29164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29165       };
29166     } catch (std::exception& e) {
29167       {
29168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29169       };
29170     } catch (Dali::DaliException e) {
29171       {
29172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29173       };
29174     } catch (...) {
29175       {
29176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29177       };
29178     }
29179   }
29180
29181 }
29182
29183
29184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29185   unsigned int jresult ;
29186   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29187   bool result;
29188
29189   arg1 = (Dali::RenderTask *)jarg1;
29190   {
29191     try {
29192       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29193     } catch (std::out_of_range& e) {
29194       {
29195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29196       };
29197     } catch (std::exception& e) {
29198       {
29199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29200       };
29201     } catch (Dali::DaliException e) {
29202       {
29203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29204       };
29205     } catch (...) {
29206       {
29207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29208       };
29209     }
29210   }
29211
29212   jresult = result;
29213   return jresult;
29214 }
29215
29216
29217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29218   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29219   bool arg2 ;
29220
29221   arg1 = (Dali::RenderTask *)jarg1;
29222   arg2 = jarg2 ? true : false;
29223   {
29224     try {
29225       (arg1)->SetCullMode(arg2);
29226     } catch (std::out_of_range& e) {
29227       {
29228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29229       };
29230     } catch (std::exception& e) {
29231       {
29232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29233       };
29234     } catch (Dali::DaliException e) {
29235       {
29236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29237       };
29238     } catch (...) {
29239       {
29240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29241       };
29242     }
29243   }
29244
29245 }
29246
29247
29248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29249   unsigned int jresult ;
29250   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29251   bool result;
29252
29253   arg1 = (Dali::RenderTask *)jarg1;
29254   {
29255     try {
29256       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29257     } catch (std::out_of_range& e) {
29258       {
29259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29260       };
29261     } catch (std::exception& e) {
29262       {
29263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29264       };
29265     } catch (Dali::DaliException e) {
29266       {
29267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29268       };
29269     } catch (...) {
29270       {
29271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29272       };
29273     }
29274   }
29275
29276   jresult = result;
29277   return jresult;
29278 }
29279
29280
29281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29282   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29283   unsigned int arg2 ;
29284
29285   arg1 = (Dali::RenderTask *)jarg1;
29286   arg2 = (unsigned int)jarg2;
29287   {
29288     try {
29289       (arg1)->SetRefreshRate(arg2);
29290     } catch (std::out_of_range& e) {
29291       {
29292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29293       };
29294     } catch (std::exception& e) {
29295       {
29296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29297       };
29298     } catch (Dali::DaliException e) {
29299       {
29300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29301       };
29302     } catch (...) {
29303       {
29304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29305       };
29306     }
29307   }
29308
29309 }
29310
29311
29312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29313   unsigned int jresult ;
29314   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29315   unsigned int result;
29316
29317   arg1 = (Dali::RenderTask *)jarg1;
29318   {
29319     try {
29320       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29321     } catch (std::out_of_range& e) {
29322       {
29323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29324       };
29325     } catch (std::exception& e) {
29326       {
29327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29328       };
29329     } catch (Dali::DaliException e) {
29330       {
29331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29332       };
29333     } catch (...) {
29334       {
29335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29336       };
29337     }
29338   }
29339
29340   jresult = result;
29341   return jresult;
29342 }
29343
29344
29345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29346   unsigned int jresult ;
29347   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29348   Dali::Vector3 *arg2 = 0 ;
29349   float *arg3 = 0 ;
29350   float *arg4 = 0 ;
29351   bool result;
29352
29353   arg1 = (Dali::RenderTask *)jarg1;
29354   arg2 = (Dali::Vector3 *)jarg2;
29355   if (!arg2) {
29356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29357     return 0;
29358   }
29359   arg3 = (float *)jarg3;
29360   arg4 = (float *)jarg4;
29361   {
29362     try {
29363       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29364     } catch (std::out_of_range& e) {
29365       {
29366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29367       };
29368     } catch (std::exception& e) {
29369       {
29370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29371       };
29372     } catch (Dali::DaliException e) {
29373       {
29374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29375       };
29376     } catch (...) {
29377       {
29378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29379       };
29380     }
29381   }
29382
29383   jresult = result;
29384   return jresult;
29385 }
29386
29387
29388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29389   unsigned int jresult ;
29390   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29391   Dali::Actor arg2 ;
29392   float arg3 ;
29393   float arg4 ;
29394   float *arg5 = 0 ;
29395   float *arg6 = 0 ;
29396   Dali::Actor *argp2 ;
29397   bool result;
29398
29399   arg1 = (Dali::RenderTask *)jarg1;
29400   argp2 = (Dali::Actor *)jarg2;
29401   if (!argp2) {
29402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29403     return 0;
29404   }
29405   arg2 = *argp2;
29406   arg3 = (float)jarg3;
29407   arg4 = (float)jarg4;
29408   arg5 = (float *)jarg5;
29409   arg6 = (float *)jarg6;
29410   {
29411     try {
29412       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29413     } catch (std::out_of_range& e) {
29414       {
29415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29416       };
29417     } catch (std::exception& e) {
29418       {
29419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29420       };
29421     } catch (Dali::DaliException e) {
29422       {
29423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29424       };
29425     } catch (...) {
29426       {
29427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29428       };
29429     }
29430   }
29431
29432   jresult = result;
29433   return jresult;
29434 }
29435
29436
29437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29438   void * jresult ;
29439   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29440   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29441
29442   arg1 = (Dali::RenderTask *)jarg1;
29443   {
29444     try {
29445       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29446     } catch (std::out_of_range& e) {
29447       {
29448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29449       };
29450     } catch (std::exception& e) {
29451       {
29452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29453       };
29454     } catch (Dali::DaliException e) {
29455       {
29456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29457       };
29458     } catch (...) {
29459       {
29460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29461       };
29462     }
29463   }
29464
29465   jresult = (void *)result;
29466   return jresult;
29467 }
29468
29469
29470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29471   void * jresult ;
29472   int arg1 ;
29473   Dali::TouchPoint::State arg2 ;
29474   float arg3 ;
29475   float arg4 ;
29476   Dali::TouchPoint *result = 0 ;
29477
29478   arg1 = (int)jarg1;
29479   arg2 = (Dali::TouchPoint::State)jarg2;
29480   arg3 = (float)jarg3;
29481   arg4 = (float)jarg4;
29482   {
29483     try {
29484       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29485     } catch (std::out_of_range& e) {
29486       {
29487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29488       };
29489     } catch (std::exception& e) {
29490       {
29491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29492       };
29493     } catch (Dali::DaliException e) {
29494       {
29495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29496       };
29497     } catch (...) {
29498       {
29499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29500       };
29501     }
29502   }
29503
29504   jresult = (void *)result;
29505   return jresult;
29506 }
29507
29508
29509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29510   void * jresult ;
29511   int arg1 ;
29512   Dali::TouchPoint::State arg2 ;
29513   float arg3 ;
29514   float arg4 ;
29515   float arg5 ;
29516   float arg6 ;
29517   Dali::TouchPoint *result = 0 ;
29518
29519   arg1 = (int)jarg1;
29520   arg2 = (Dali::TouchPoint::State)jarg2;
29521   arg3 = (float)jarg3;
29522   arg4 = (float)jarg4;
29523   arg5 = (float)jarg5;
29524   arg6 = (float)jarg6;
29525   {
29526     try {
29527       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29528     } catch (std::out_of_range& e) {
29529       {
29530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29531       };
29532     } catch (std::exception& e) {
29533       {
29534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29535       };
29536     } catch (Dali::DaliException e) {
29537       {
29538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29539       };
29540     } catch (...) {
29541       {
29542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29543       };
29544     }
29545   }
29546
29547   jresult = (void *)result;
29548   return jresult;
29549 }
29550
29551
29552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29553   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29554
29555   arg1 = (Dali::TouchPoint *)jarg1;
29556   {
29557     try {
29558       delete arg1;
29559     } catch (std::out_of_range& e) {
29560       {
29561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29562       };
29563     } catch (std::exception& e) {
29564       {
29565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29566       };
29567     } catch (Dali::DaliException e) {
29568       {
29569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29570       };
29571     } catch (...) {
29572       {
29573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29574       };
29575     }
29576   }
29577
29578 }
29579
29580
29581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29582   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29583   int arg2 ;
29584
29585   arg1 = (Dali::TouchPoint *)jarg1;
29586   arg2 = (int)jarg2;
29587   if (arg1) (arg1)->deviceId = arg2;
29588 }
29589
29590
29591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29592   int jresult ;
29593   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29594   int result;
29595
29596   arg1 = (Dali::TouchPoint *)jarg1;
29597   result = (int) ((arg1)->deviceId);
29598   jresult = result;
29599   return jresult;
29600 }
29601
29602
29603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29604   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29605   Dali::TouchPoint::State arg2 ;
29606
29607   arg1 = (Dali::TouchPoint *)jarg1;
29608   arg2 = (Dali::TouchPoint::State)jarg2;
29609   if (arg1) (arg1)->state = arg2;
29610 }
29611
29612
29613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29614   int jresult ;
29615   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29616   Dali::TouchPoint::State result;
29617
29618   arg1 = (Dali::TouchPoint *)jarg1;
29619   result = (Dali::TouchPoint::State) ((arg1)->state);
29620   jresult = (int)result;
29621   return jresult;
29622 }
29623
29624
29625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29626   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29627   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29628
29629   arg1 = (Dali::TouchPoint *)jarg1;
29630   arg2 = (Dali::Actor *)jarg2;
29631   if (arg1) (arg1)->hitActor = *arg2;
29632 }
29633
29634
29635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29636   void * jresult ;
29637   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29638   Dali::Actor *result = 0 ;
29639
29640   arg1 = (Dali::TouchPoint *)jarg1;
29641   result = (Dali::Actor *)& ((arg1)->hitActor);
29642   jresult = (void *)result;
29643   return jresult;
29644 }
29645
29646
29647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29648   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29649   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29650
29651   arg1 = (Dali::TouchPoint *)jarg1;
29652   arg2 = (Dali::Vector2 *)jarg2;
29653   if (arg1) (arg1)->local = *arg2;
29654 }
29655
29656
29657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29658   void * jresult ;
29659   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29660   Dali::Vector2 *result = 0 ;
29661
29662   arg1 = (Dali::TouchPoint *)jarg1;
29663   result = (Dali::Vector2 *)& ((arg1)->local);
29664   jresult = (void *)result;
29665   return jresult;
29666 }
29667
29668
29669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29670   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29671   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29672
29673   arg1 = (Dali::TouchPoint *)jarg1;
29674   arg2 = (Dali::Vector2 *)jarg2;
29675   if (arg1) (arg1)->screen = *arg2;
29676 }
29677
29678
29679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29680   void * jresult ;
29681   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29682   Dali::Vector2 *result = 0 ;
29683
29684   arg1 = (Dali::TouchPoint *)jarg1;
29685   result = (Dali::Vector2 *)& ((arg1)->screen);
29686   jresult = (void *)result;
29687   return jresult;
29688 }
29689
29690
29691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29692   void * jresult ;
29693   Dali::TouchData *result = 0 ;
29694
29695   {
29696     try {
29697       result = (Dali::TouchData *)new Dali::TouchData();
29698     } catch (std::out_of_range& e) {
29699       {
29700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29701       };
29702     } catch (std::exception& e) {
29703       {
29704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29705       };
29706     } catch (Dali::DaliException e) {
29707       {
29708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29709       };
29710     } catch (...) {
29711       {
29712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29713       };
29714     }
29715   }
29716
29717   jresult = (void *)result;
29718   return jresult;
29719 }
29720
29721
29722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29723   void * jresult ;
29724   Dali::TouchData *arg1 = 0 ;
29725   Dali::TouchData *result = 0 ;
29726
29727   arg1 = (Dali::TouchData *)jarg1;
29728   if (!arg1) {
29729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29730     return 0;
29731   }
29732   {
29733     try {
29734       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29735     } catch (std::out_of_range& e) {
29736       {
29737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29738       };
29739     } catch (std::exception& e) {
29740       {
29741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29742       };
29743     } catch (Dali::DaliException e) {
29744       {
29745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29746       };
29747     } catch (...) {
29748       {
29749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29750       };
29751     }
29752   }
29753
29754   jresult = (void *)result;
29755   return jresult;
29756 }
29757
29758
29759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29760   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29761
29762   arg1 = (Dali::TouchData *)jarg1;
29763   {
29764     try {
29765       delete arg1;
29766     } catch (std::out_of_range& e) {
29767       {
29768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29769       };
29770     } catch (std::exception& e) {
29771       {
29772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29773       };
29774     } catch (Dali::DaliException e) {
29775       {
29776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29777       };
29778     } catch (...) {
29779       {
29780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29781       };
29782     }
29783   }
29784
29785 }
29786
29787
29788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29789   void * jresult ;
29790   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29791   Dali::TouchData *arg2 = 0 ;
29792   Dali::TouchData *result = 0 ;
29793
29794   arg1 = (Dali::TouchData *)jarg1;
29795   arg2 = (Dali::TouchData *)jarg2;
29796   if (!arg2) {
29797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29798     return 0;
29799   }
29800   {
29801     try {
29802       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29803     } catch (std::out_of_range& e) {
29804       {
29805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29806       };
29807     } catch (std::exception& e) {
29808       {
29809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29810       };
29811     } catch (Dali::DaliException e) {
29812       {
29813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29814       };
29815     } catch (...) {
29816       {
29817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29818       };
29819     }
29820   }
29821
29822   jresult = (void *)result;
29823   return jresult;
29824 }
29825
29826
29827 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29828   unsigned long jresult ;
29829   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29830   unsigned long result;
29831
29832   arg1 = (Dali::TouchData *)jarg1;
29833   {
29834     try {
29835       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29836     } catch (std::out_of_range& e) {
29837       {
29838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29839       };
29840     } catch (std::exception& e) {
29841       {
29842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29843       };
29844     } catch (Dali::DaliException e) {
29845       {
29846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29847       };
29848     } catch (...) {
29849       {
29850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29851       };
29852     }
29853   }
29854
29855   jresult = (unsigned long)result;
29856   return jresult;
29857 }
29858
29859
29860 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29861   unsigned long jresult ;
29862   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29863   std::size_t result;
29864
29865   arg1 = (Dali::TouchData *)jarg1;
29866   {
29867     try {
29868       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29869     } catch (std::out_of_range& e) {
29870       {
29871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29872       };
29873     } catch (std::exception& e) {
29874       {
29875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29876       };
29877     } catch (Dali::DaliException e) {
29878       {
29879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29880       };
29881     } catch (...) {
29882       {
29883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29884       };
29885     }
29886   }
29887
29888   jresult = (unsigned long)result;
29889   return jresult;
29890 }
29891
29892
29893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29894   int jresult ;
29895   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29896   std::size_t arg2 ;
29897   int32_t result;
29898
29899   arg1 = (Dali::TouchData *)jarg1;
29900   arg2 = (std::size_t)jarg2;
29901   {
29902     try {
29903       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29904     } catch (std::out_of_range& e) {
29905       {
29906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29907       };
29908     } catch (std::exception& e) {
29909       {
29910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29911       };
29912     } catch (Dali::DaliException e) {
29913       {
29914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29915       };
29916     } catch (...) {
29917       {
29918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29919       };
29920     }
29921   }
29922
29923   jresult = result;
29924   return jresult;
29925 }
29926
29927
29928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29929   int jresult ;
29930   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29931   std::size_t arg2 ;
29932   Dali::PointState::Type result;
29933
29934   arg1 = (Dali::TouchData *)jarg1;
29935   arg2 = (std::size_t)jarg2;
29936   {
29937     try {
29938       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29939     } catch (std::out_of_range& e) {
29940       {
29941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29942       };
29943     } catch (std::exception& e) {
29944       {
29945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29946       };
29947     } catch (Dali::DaliException e) {
29948       {
29949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29950       };
29951     } catch (...) {
29952       {
29953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29954       };
29955     }
29956   }
29957
29958   jresult = (int)result;
29959   return jresult;
29960 }
29961
29962
29963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29964   void * jresult ;
29965   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29966   std::size_t arg2 ;
29967   Dali::Actor result;
29968
29969   arg1 = (Dali::TouchData *)jarg1;
29970   arg2 = (std::size_t)jarg2;
29971   {
29972     try {
29973       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29974     } catch (std::out_of_range& e) {
29975       {
29976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29977       };
29978     } catch (std::exception& e) {
29979       {
29980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29981       };
29982     } catch (Dali::DaliException e) {
29983       {
29984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29985       };
29986     } catch (...) {
29987       {
29988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29989       };
29990     }
29991   }
29992
29993   jresult = new Dali::Actor((const Dali::Actor &)result);
29994   return jresult;
29995 }
29996
29997
29998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29999   void * jresult ;
30000   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30001   std::size_t arg2 ;
30002   Dali::Vector2 *result = 0 ;
30003
30004   arg1 = (Dali::TouchData *)jarg1;
30005   arg2 = (std::size_t)jarg2;
30006   {
30007     try {
30008       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30009     } catch (std::out_of_range& e) {
30010       {
30011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30012       };
30013     } catch (std::exception& e) {
30014       {
30015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30016       };
30017     } catch (Dali::DaliException e) {
30018       {
30019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30020       };
30021     } catch (...) {
30022       {
30023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30024       };
30025     }
30026   }
30027
30028   jresult = (void *)result;
30029   return jresult;
30030 }
30031
30032
30033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30034   void * jresult ;
30035   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30036   std::size_t arg2 ;
30037   Dali::Vector2 *result = 0 ;
30038
30039   arg1 = (Dali::TouchData *)jarg1;
30040   arg2 = (std::size_t)jarg2;
30041   {
30042     try {
30043       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30044     } catch (std::out_of_range& e) {
30045       {
30046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30047       };
30048     } catch (std::exception& e) {
30049       {
30050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30051       };
30052     } catch (Dali::DaliException e) {
30053       {
30054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30055       };
30056     } catch (...) {
30057       {
30058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30059       };
30060     }
30061   }
30062
30063   jresult = (void *)result;
30064   return jresult;
30065 }
30066
30067
30068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30069   float jresult ;
30070   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30071   std::size_t arg2 ;
30072   float result;
30073
30074   arg1 = (Dali::TouchData *)jarg1;
30075   arg2 = (std::size_t)jarg2;
30076   {
30077     try {
30078       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30079     } catch (std::out_of_range& e) {
30080       {
30081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30082       };
30083     } catch (std::exception& e) {
30084       {
30085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30086       };
30087     } catch (Dali::DaliException e) {
30088       {
30089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30090       };
30091     } catch (...) {
30092       {
30093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30094       };
30095     }
30096   }
30097
30098   jresult = result;
30099   return jresult;
30100 }
30101
30102
30103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30104   void * jresult ;
30105   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30106   std::size_t arg2 ;
30107   Dali::Vector2 *result = 0 ;
30108
30109   arg1 = (Dali::TouchData *)jarg1;
30110   arg2 = (std::size_t)jarg2;
30111   {
30112     try {
30113       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30114     } catch (std::out_of_range& e) {
30115       {
30116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30117       };
30118     } catch (std::exception& e) {
30119       {
30120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30121       };
30122     } catch (Dali::DaliException e) {
30123       {
30124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30125       };
30126     } catch (...) {
30127       {
30128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30129       };
30130     }
30131   }
30132
30133   jresult = (void *)result;
30134   return jresult;
30135 }
30136
30137
30138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30139   float jresult ;
30140   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30141   std::size_t arg2 ;
30142   float result;
30143
30144   arg1 = (Dali::TouchData *)jarg1;
30145   arg2 = (std::size_t)jarg2;
30146   {
30147     try {
30148       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30149     } catch (std::out_of_range& e) {
30150       {
30151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30152       };
30153     } catch (std::exception& e) {
30154       {
30155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30156       };
30157     } catch (Dali::DaliException e) {
30158       {
30159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30160       };
30161     } catch (...) {
30162       {
30163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30164       };
30165     }
30166   }
30167
30168   jresult = result;
30169   return jresult;
30170 }
30171
30172
30173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30174   void * jresult ;
30175   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30176   std::size_t arg2 ;
30177   Dali::Degree result;
30178
30179   arg1 = (Dali::TouchData *)jarg1;
30180   arg2 = (std::size_t)jarg2;
30181   {
30182     try {
30183       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30184     } catch (std::out_of_range& e) {
30185       {
30186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30187       };
30188     } catch (std::exception& e) {
30189       {
30190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30191       };
30192     } catch (Dali::DaliException e) {
30193       {
30194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30195       };
30196     } catch (...) {
30197       {
30198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30199       };
30200     }
30201   }
30202
30203   jresult = new Dali::Degree((const Dali::Degree &)result);
30204   return jresult;
30205 }
30206
30207
30208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30209   int jresult ;
30210   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30211   std::size_t arg2 ;
30212   Dali::MouseButton::Type result;
30213
30214   arg1 = (Dali::TouchData *)jarg1;
30215   arg2 = (std::size_t)jarg2;
30216   {
30217     try {
30218       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30219     } catch (std::out_of_range& e) {
30220       {
30221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30222       };
30223     } catch (std::exception& e) {
30224       {
30225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30226       };
30227     } catch (Dali::DaliException e) {
30228       {
30229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30230       };
30231     } catch (...) {
30232       {
30233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30234       };
30235     }
30236   }
30237
30238   jresult = static_cast< int >(result);
30239   return jresult;
30240 }
30241
30242
30243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30244   void * jresult ;
30245   Dali::GestureDetector *result = 0 ;
30246
30247   {
30248     try {
30249       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30250     } catch (std::out_of_range& e) {
30251       {
30252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30253       };
30254     } catch (std::exception& e) {
30255       {
30256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30257       };
30258     } catch (Dali::DaliException e) {
30259       {
30260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30261       };
30262     } catch (...) {
30263       {
30264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30265       };
30266     }
30267   }
30268
30269   jresult = (void *)result;
30270   return jresult;
30271 }
30272
30273
30274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30275   void * jresult ;
30276   Dali::BaseHandle arg1 ;
30277   Dali::BaseHandle *argp1 ;
30278   Dali::GestureDetector result;
30279
30280   argp1 = (Dali::BaseHandle *)jarg1;
30281   if (!argp1) {
30282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30283     return 0;
30284   }
30285   arg1 = *argp1;
30286   {
30287     try {
30288       result = Dali::GestureDetector::DownCast(arg1);
30289     } catch (std::out_of_range& e) {
30290       {
30291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30292       };
30293     } catch (std::exception& e) {
30294       {
30295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30296       };
30297     } catch (Dali::DaliException e) {
30298       {
30299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30300       };
30301     } catch (...) {
30302       {
30303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30304       };
30305     }
30306   }
30307
30308   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30309   return jresult;
30310 }
30311
30312
30313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30314   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30315
30316   arg1 = (Dali::GestureDetector *)jarg1;
30317   {
30318     try {
30319       delete arg1;
30320     } catch (std::out_of_range& e) {
30321       {
30322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30323       };
30324     } catch (std::exception& e) {
30325       {
30326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30327       };
30328     } catch (Dali::DaliException e) {
30329       {
30330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30331       };
30332     } catch (...) {
30333       {
30334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30335       };
30336     }
30337   }
30338
30339 }
30340
30341
30342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30343   void * jresult ;
30344   Dali::GestureDetector *arg1 = 0 ;
30345   Dali::GestureDetector *result = 0 ;
30346
30347   arg1 = (Dali::GestureDetector *)jarg1;
30348   if (!arg1) {
30349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30350     return 0;
30351   }
30352   {
30353     try {
30354       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30355     } catch (std::out_of_range& e) {
30356       {
30357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30358       };
30359     } catch (std::exception& e) {
30360       {
30361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30362       };
30363     } catch (Dali::DaliException e) {
30364       {
30365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30366       };
30367     } catch (...) {
30368       {
30369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30370       };
30371     }
30372   }
30373
30374   jresult = (void *)result;
30375   return jresult;
30376 }
30377
30378
30379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30380   void * jresult ;
30381   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30382   Dali::GestureDetector *arg2 = 0 ;
30383   Dali::GestureDetector *result = 0 ;
30384
30385   arg1 = (Dali::GestureDetector *)jarg1;
30386   arg2 = (Dali::GestureDetector *)jarg2;
30387   if (!arg2) {
30388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30389     return 0;
30390   }
30391   {
30392     try {
30393       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30394     } catch (std::out_of_range& e) {
30395       {
30396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30397       };
30398     } catch (std::exception& e) {
30399       {
30400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30401       };
30402     } catch (Dali::DaliException e) {
30403       {
30404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30405       };
30406     } catch (...) {
30407       {
30408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30409       };
30410     }
30411   }
30412
30413   jresult = (void *)result;
30414   return jresult;
30415 }
30416
30417
30418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30419   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30420   Dali::Actor arg2 ;
30421   Dali::Actor *argp2 ;
30422
30423   arg1 = (Dali::GestureDetector *)jarg1;
30424   argp2 = (Dali::Actor *)jarg2;
30425   if (!argp2) {
30426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30427     return ;
30428   }
30429   arg2 = *argp2;
30430   {
30431     try {
30432       (arg1)->Attach(arg2);
30433     } catch (std::out_of_range& e) {
30434       {
30435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30436       };
30437     } catch (std::exception& e) {
30438       {
30439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30440       };
30441     } catch (Dali::DaliException e) {
30442       {
30443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30444       };
30445     } catch (...) {
30446       {
30447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30448       };
30449     }
30450   }
30451
30452 }
30453
30454
30455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30456   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30457   Dali::Actor arg2 ;
30458   Dali::Actor *argp2 ;
30459
30460   arg1 = (Dali::GestureDetector *)jarg1;
30461   argp2 = (Dali::Actor *)jarg2;
30462   if (!argp2) {
30463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30464     return ;
30465   }
30466   arg2 = *argp2;
30467   {
30468     try {
30469       (arg1)->Detach(arg2);
30470     } catch (std::out_of_range& e) {
30471       {
30472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30473       };
30474     } catch (std::exception& e) {
30475       {
30476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30477       };
30478     } catch (Dali::DaliException e) {
30479       {
30480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30481       };
30482     } catch (...) {
30483       {
30484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30485       };
30486     }
30487   }
30488
30489 }
30490
30491
30492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30493   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30494
30495   arg1 = (Dali::GestureDetector *)jarg1;
30496   {
30497     try {
30498       (arg1)->DetachAll();
30499     } catch (std::out_of_range& e) {
30500       {
30501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30502       };
30503     } catch (std::exception& e) {
30504       {
30505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30506       };
30507     } catch (Dali::DaliException e) {
30508       {
30509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30510       };
30511     } catch (...) {
30512       {
30513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30514       };
30515     }
30516   }
30517
30518 }
30519
30520
30521 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30522   unsigned long jresult ;
30523   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30524   size_t result;
30525
30526   arg1 = (Dali::GestureDetector *)jarg1;
30527   {
30528     try {
30529       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30530     } catch (std::out_of_range& e) {
30531       {
30532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30533       };
30534     } catch (std::exception& e) {
30535       {
30536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30537       };
30538     } catch (Dali::DaliException e) {
30539       {
30540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30541       };
30542     } catch (...) {
30543       {
30544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30545       };
30546     }
30547   }
30548
30549   jresult = (unsigned long)result;
30550   return jresult;
30551 }
30552
30553
30554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30555   void * jresult ;
30556   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30557   size_t arg2 ;
30558   Dali::Actor result;
30559
30560   arg1 = (Dali::GestureDetector *)jarg1;
30561   arg2 = (size_t)jarg2;
30562   {
30563     try {
30564       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30565     } catch (std::out_of_range& e) {
30566       {
30567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30568       };
30569     } catch (std::exception& e) {
30570       {
30571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30572       };
30573     } catch (Dali::DaliException e) {
30574       {
30575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30576       };
30577     } catch (...) {
30578       {
30579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30580       };
30581     }
30582   }
30583
30584   jresult = new Dali::Actor((const Dali::Actor &)result);
30585   return jresult;
30586 }
30587
30588
30589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30590   void * jresult ;
30591   Dali::Gesture *arg1 = 0 ;
30592   Dali::Gesture *result = 0 ;
30593
30594   arg1 = (Dali::Gesture *)jarg1;
30595   if (!arg1) {
30596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30597     return 0;
30598   }
30599   {
30600     try {
30601       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30602     } catch (std::out_of_range& e) {
30603       {
30604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30605       };
30606     } catch (std::exception& e) {
30607       {
30608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30609       };
30610     } catch (Dali::DaliException e) {
30611       {
30612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30613       };
30614     } catch (...) {
30615       {
30616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30617       };
30618     }
30619   }
30620
30621   jresult = (void *)result;
30622   return jresult;
30623 }
30624
30625
30626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30627   void * jresult ;
30628   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30629   Dali::Gesture *arg2 = 0 ;
30630   Dali::Gesture *result = 0 ;
30631
30632   arg1 = (Dali::Gesture *)jarg1;
30633   arg2 = (Dali::Gesture *)jarg2;
30634   if (!arg2) {
30635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30636     return 0;
30637   }
30638   {
30639     try {
30640       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30641     } catch (std::out_of_range& e) {
30642       {
30643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30644       };
30645     } catch (std::exception& e) {
30646       {
30647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30648       };
30649     } catch (Dali::DaliException e) {
30650       {
30651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30652       };
30653     } catch (...) {
30654       {
30655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30656       };
30657     }
30658   }
30659
30660   jresult = (void *)result;
30661   return jresult;
30662 }
30663
30664
30665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30666   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30667
30668   arg1 = (Dali::Gesture *)jarg1;
30669   {
30670     try {
30671       delete arg1;
30672     } catch (std::out_of_range& e) {
30673       {
30674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30675       };
30676     } catch (std::exception& e) {
30677       {
30678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30679       };
30680     } catch (Dali::DaliException e) {
30681       {
30682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30683       };
30684     } catch (...) {
30685       {
30686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30687       };
30688     }
30689   }
30690
30691 }
30692
30693
30694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30695   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30696   Dali::Gesture::Type arg2 ;
30697
30698   arg1 = (Dali::Gesture *)jarg1;
30699   arg2 = (Dali::Gesture::Type)jarg2;
30700   if (arg1) (arg1)->type = arg2;
30701 }
30702
30703
30704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30705   int jresult ;
30706   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30707   Dali::Gesture::Type result;
30708
30709   arg1 = (Dali::Gesture *)jarg1;
30710   result = (Dali::Gesture::Type) ((arg1)->type);
30711   jresult = (int)result;
30712   return jresult;
30713 }
30714
30715
30716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30717   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30718   Dali::Gesture::State arg2 ;
30719
30720   arg1 = (Dali::Gesture *)jarg1;
30721   arg2 = (Dali::Gesture::State)jarg2;
30722   if (arg1) (arg1)->state = arg2;
30723 }
30724
30725
30726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30727   int jresult ;
30728   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30729   Dali::Gesture::State result;
30730
30731   arg1 = (Dali::Gesture *)jarg1;
30732   result = (Dali::Gesture::State) ((arg1)->state);
30733   jresult = (int)result;
30734   return jresult;
30735 }
30736
30737
30738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30739   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30740   unsigned int arg2 ;
30741
30742   arg1 = (Dali::Gesture *)jarg1;
30743   arg2 = (unsigned int)jarg2;
30744   if (arg1) (arg1)->time = arg2;
30745 }
30746
30747
30748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30749   unsigned int jresult ;
30750   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30751   unsigned int result;
30752
30753   arg1 = (Dali::Gesture *)jarg1;
30754   result = (unsigned int) ((arg1)->time);
30755   jresult = result;
30756   return jresult;
30757 }
30758
30759
30760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30761   void * jresult ;
30762   Dali::HoverEvent *result = 0 ;
30763
30764   {
30765     try {
30766       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30767     } catch (std::out_of_range& e) {
30768       {
30769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30770       };
30771     } catch (std::exception& e) {
30772       {
30773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30774       };
30775     } catch (Dali::DaliException e) {
30776       {
30777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30778       };
30779     } catch (...) {
30780       {
30781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30782       };
30783     }
30784   }
30785
30786   jresult = (void *)result;
30787   return jresult;
30788 }
30789
30790
30791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30792   void * jresult ;
30793   unsigned long arg1 ;
30794   Dali::HoverEvent *result = 0 ;
30795
30796   arg1 = (unsigned long)jarg1;
30797   {
30798     try {
30799       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30800     } catch (std::out_of_range& e) {
30801       {
30802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30803       };
30804     } catch (std::exception& e) {
30805       {
30806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30807       };
30808     } catch (Dali::DaliException e) {
30809       {
30810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30811       };
30812     } catch (...) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30815       };
30816     }
30817   }
30818
30819   jresult = (void *)result;
30820   return jresult;
30821 }
30822
30823
30824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30825   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30826
30827   arg1 = (Dali::HoverEvent *)jarg1;
30828   {
30829     try {
30830       delete arg1;
30831     } catch (std::out_of_range& e) {
30832       {
30833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30834       };
30835     } catch (std::exception& e) {
30836       {
30837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30838       };
30839     } catch (Dali::DaliException e) {
30840       {
30841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30842       };
30843     } catch (...) {
30844       {
30845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30846       };
30847     }
30848   }
30849
30850 }
30851
30852
30853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30854   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30855   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30856
30857   arg1 = (Dali::HoverEvent *)jarg1;
30858   arg2 = (Dali::TouchPointContainer *)jarg2;
30859   if (arg1) (arg1)->points = *arg2;
30860 }
30861
30862
30863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30864   void * jresult ;
30865   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30866   Dali::TouchPointContainer *result = 0 ;
30867
30868   arg1 = (Dali::HoverEvent *)jarg1;
30869   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30870   jresult = (void *)result;
30871   return jresult;
30872 }
30873
30874
30875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30876   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30877   unsigned long arg2 ;
30878
30879   arg1 = (Dali::HoverEvent *)jarg1;
30880   arg2 = (unsigned long)jarg2;
30881   if (arg1) (arg1)->time = arg2;
30882 }
30883
30884
30885 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30886   unsigned long jresult ;
30887   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30888   unsigned long result;
30889
30890   arg1 = (Dali::HoverEvent *)jarg1;
30891   result = (unsigned long) ((arg1)->time);
30892   jresult = (unsigned long)result;
30893   return jresult;
30894 }
30895
30896
30897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30898   unsigned int jresult ;
30899   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30900   unsigned int result;
30901
30902   arg1 = (Dali::HoverEvent *)jarg1;
30903   {
30904     try {
30905       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30906     } catch (std::out_of_range& e) {
30907       {
30908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30909       };
30910     } catch (std::exception& e) {
30911       {
30912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30913       };
30914     } catch (Dali::DaliException e) {
30915       {
30916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30917       };
30918     } catch (...) {
30919       {
30920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30921       };
30922     }
30923   }
30924
30925   jresult = result;
30926   return jresult;
30927 }
30928
30929
30930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30931   void * jresult ;
30932   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30933   unsigned int arg2 ;
30934   Dali::TouchPoint *result = 0 ;
30935
30936   arg1 = (Dali::HoverEvent *)jarg1;
30937   arg2 = (unsigned int)jarg2;
30938   {
30939     try {
30940       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30941     } catch (std::out_of_range& e) {
30942       {
30943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30944       };
30945     } catch (std::exception& e) {
30946       {
30947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (Dali::DaliException e) {
30950       {
30951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30952       };
30953     } catch (...) {
30954       {
30955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30956       };
30957     }
30958   }
30959
30960   jresult = (void *)result;
30961   return jresult;
30962 }
30963
30964
30965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30966   void * jresult ;
30967   Dali::KeyEvent *result = 0 ;
30968
30969   {
30970     try {
30971       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30972     } catch (std::out_of_range& e) {
30973       {
30974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30975       };
30976     } catch (std::exception& e) {
30977       {
30978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30979       };
30980     } catch (Dali::DaliException e) {
30981       {
30982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30983       };
30984     } catch (...) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30987       };
30988     }
30989   }
30990
30991   jresult = (void *)result;
30992   return jresult;
30993 }
30994
30995
30996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30997   void * jresult ;
30998   std::string *arg1 = 0 ;
30999   std::string *arg2 = 0 ;
31000   int arg3 ;
31001   int arg4 ;
31002   unsigned long arg5 ;
31003   Dali::KeyEvent::State *arg6 = 0 ;
31004   Dali::KeyEvent::State temp6 ;
31005   Dali::KeyEvent *result = 0 ;
31006
31007   if (!jarg1) {
31008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31009     return 0;
31010   }
31011   std::string arg1_str(jarg1);
31012   arg1 = &arg1_str;
31013   if (!jarg2) {
31014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31015     return 0;
31016   }
31017   std::string arg2_str(jarg2);
31018   arg2 = &arg2_str;
31019   arg3 = (int)jarg3;
31020   arg4 = (int)jarg4;
31021   arg5 = (unsigned long)jarg5;
31022   temp6 = (Dali::KeyEvent::State)jarg6;
31023   arg6 = &temp6;
31024   {
31025     try {
31026       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31027     } catch (std::out_of_range& e) {
31028       {
31029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31030       };
31031     } catch (std::exception& e) {
31032       {
31033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31034       };
31035     } catch (Dali::DaliException e) {
31036       {
31037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31038       };
31039     } catch (...) {
31040       {
31041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31042       };
31043     }
31044   }
31045
31046   jresult = (void *)result;
31047
31048   //argout typemap for const std::string&
31049
31050
31051   //argout typemap for const std::string&
31052
31053   return jresult;
31054 }
31055
31056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31057   void * jresult ;
31058   Dali::KeyEvent *arg1 = 0 ;
31059   Dali::KeyEvent *result = 0 ;
31060
31061   arg1 = (Dali::KeyEvent *)jarg1;
31062   if (!arg1) {
31063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31064     return 0;
31065   }
31066   {
31067     try {
31068       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31069     } catch (std::out_of_range& e) {
31070       {
31071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31072       };
31073     } catch (std::exception& e) {
31074       {
31075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31076       };
31077     } catch (Dali::DaliException e) {
31078       {
31079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31080       };
31081     } catch (...) {
31082       {
31083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31084       };
31085     }
31086   }
31087
31088   jresult = (void *)result;
31089   return jresult;
31090 }
31091
31092
31093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31094   void * jresult ;
31095   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31096   Dali::KeyEvent *arg2 = 0 ;
31097   Dali::KeyEvent *result = 0 ;
31098
31099   arg1 = (Dali::KeyEvent *)jarg1;
31100   arg2 = (Dali::KeyEvent *)jarg2;
31101   if (!arg2) {
31102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31103     return 0;
31104   }
31105   {
31106     try {
31107       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31108     } catch (std::out_of_range& e) {
31109       {
31110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31111       };
31112     } catch (std::exception& e) {
31113       {
31114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (Dali::DaliException e) {
31117       {
31118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31119       };
31120     } catch (...) {
31121       {
31122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31123       };
31124     }
31125   }
31126
31127   jresult = (void *)result;
31128   return jresult;
31129 }
31130
31131
31132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31133   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31134
31135   arg1 = (Dali::KeyEvent *)jarg1;
31136   {
31137     try {
31138       delete arg1;
31139     } catch (std::out_of_range& e) {
31140       {
31141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31142       };
31143     } catch (std::exception& e) {
31144       {
31145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31146       };
31147     } catch (Dali::DaliException e) {
31148       {
31149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31150       };
31151     } catch (...) {
31152       {
31153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31154       };
31155     }
31156   }
31157
31158 }
31159
31160
31161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31162   unsigned int jresult ;
31163   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31164   bool result;
31165
31166   arg1 = (Dali::KeyEvent *)jarg1;
31167   {
31168     try {
31169       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31170     } catch (std::out_of_range& e) {
31171       {
31172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31173       };
31174     } catch (std::exception& e) {
31175       {
31176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31177       };
31178     } catch (Dali::DaliException e) {
31179       {
31180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31181       };
31182     } catch (...) {
31183       {
31184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31185       };
31186     }
31187   }
31188
31189   jresult = result;
31190   return jresult;
31191 }
31192
31193
31194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31195   unsigned int jresult ;
31196   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31197   bool result;
31198
31199   arg1 = (Dali::KeyEvent *)jarg1;
31200   {
31201     try {
31202       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31203     } catch (std::out_of_range& e) {
31204       {
31205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31206       };
31207     } catch (std::exception& e) {
31208       {
31209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31210       };
31211     } catch (Dali::DaliException e) {
31212       {
31213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31214       };
31215     } catch (...) {
31216       {
31217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31218       };
31219     }
31220   }
31221
31222   jresult = result;
31223   return jresult;
31224 }
31225
31226
31227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31228   unsigned int jresult ;
31229   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31230   bool result;
31231
31232   arg1 = (Dali::KeyEvent *)jarg1;
31233   {
31234     try {
31235       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31236     } catch (std::out_of_range& e) {
31237       {
31238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31239       };
31240     } catch (std::exception& e) {
31241       {
31242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31243       };
31244     } catch (Dali::DaliException e) {
31245       {
31246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31247       };
31248     } catch (...) {
31249       {
31250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31251       };
31252     }
31253   }
31254
31255   jresult = result;
31256   return jresult;
31257 }
31258
31259
31260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31261   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31262   std::string *arg2 = 0 ;
31263
31264   arg1 = (Dali::KeyEvent *)jarg1;
31265   if (!jarg2) {
31266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31267     return ;
31268   }
31269   std::string arg2_str(jarg2);
31270   arg2 = &arg2_str;
31271   if (arg1) (arg1)->keyPressedName = *arg2;
31272
31273   //argout typemap for const std::string&
31274
31275 }
31276
31277
31278 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31279   char * jresult ;
31280
31281   if( jarg1 == NULL )
31282   {
31283     jresult = SWIG_csharp_string_callback( "" );
31284   }
31285   else
31286   {
31287     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31288     std::string *result = 0;
31289
31290     arg1 = ( Dali::KeyEvent * )jarg1;
31291     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31292     jresult = SWIG_csharp_string_callback( result->c_str() );
31293   }
31294
31295   return jresult;
31296 }
31297
31298
31299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31300   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31301   std::string *arg2 = 0 ;
31302
31303   arg1 = (Dali::KeyEvent *)jarg1;
31304   if (!jarg2) {
31305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31306     return ;
31307   }
31308   std::string arg2_str(jarg2);
31309   arg2 = &arg2_str;
31310   if (arg1) (arg1)->keyPressed = *arg2;
31311
31312   //argout typemap for const std::string&
31313
31314 }
31315
31316
31317 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31318   char * jresult ;
31319   if( NULL == jarg1 )
31320   {
31321     jresult = SWIG_csharp_string_callback( "" );
31322   }
31323   else
31324   {
31325     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31326     std::string *result = 0;
31327
31328     arg1 = ( Dali::KeyEvent * )jarg1;
31329     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31330     jresult = SWIG_csharp_string_callback( result->c_str() );
31331   }
31332   return jresult;
31333 }
31334
31335
31336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31337   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31338   int arg2 ;
31339
31340   arg1 = (Dali::KeyEvent *)jarg1;
31341   arg2 = (int)jarg2;
31342   if (arg1) (arg1)->keyCode = arg2;
31343 }
31344
31345
31346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31347   int jresult ;
31348   if( NULL == jarg1 )
31349   {
31350     jresult = -1;
31351   }
31352   else
31353   {
31354     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31355     int result;
31356
31357     arg1 = ( Dali::KeyEvent * )jarg1;
31358     result = (int)( ( arg1 )->keyCode );
31359     jresult = result;
31360   }
31361   return jresult;
31362 }
31363
31364
31365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31366   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31367   int arg2 ;
31368
31369   arg1 = (Dali::KeyEvent *)jarg1;
31370   arg2 = (int)jarg2;
31371   if (arg1) (arg1)->keyModifier = arg2;
31372 }
31373
31374
31375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31376   int jresult ;
31377   if( jarg1 == NULL )
31378   {
31379     jresult = -1;
31380   }
31381   else
31382   {
31383     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31384     int result;
31385
31386     arg1 = ( Dali::KeyEvent * )jarg1;
31387     result = (int)( ( arg1 )->keyModifier );
31388     jresult = result;
31389   }
31390   return jresult;
31391 }
31392
31393
31394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31395   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31396   unsigned long arg2 ;
31397
31398   arg1 = (Dali::KeyEvent *)jarg1;
31399   arg2 = (unsigned long)jarg2;
31400   if (arg1) (arg1)->time = arg2;
31401 }
31402
31403
31404 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31405   unsigned long jresult ;
31406   if( jarg1 == NULL )
31407   {
31408     jresult = 0;
31409   }
31410   else
31411   {
31412     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31413     unsigned long result;
31414
31415     arg1 = ( Dali::KeyEvent * )jarg1;
31416     result = (unsigned long)( ( arg1 )->time );
31417     jresult = (unsigned long)result;
31418   }
31419   return jresult;
31420 }
31421
31422
31423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31424   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31425   Dali::KeyEvent::State arg2 ;
31426
31427   arg1 = (Dali::KeyEvent *)jarg1;
31428   arg2 = (Dali::KeyEvent::State)jarg2;
31429   if (arg1) (arg1)->state = arg2;
31430 }
31431
31432
31433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31434   int jresult ;
31435   if( jarg1 == NULL )
31436   {
31437     jresult = -1;
31438   }
31439   else
31440   {
31441     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31442     Dali::KeyEvent::State result;
31443
31444     arg1 = ( Dali::KeyEvent * )jarg1;
31445     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31446     jresult = (int)result;
31447   }
31448   return jresult;
31449 }
31450
31451
31452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31453   void * jresult ;
31454   Dali::LongPressGestureDetector *result = 0 ;
31455
31456   {
31457     try {
31458       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31459     } catch (std::out_of_range& e) {
31460       {
31461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31462       };
31463     } catch (std::exception& e) {
31464       {
31465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31466       };
31467     } catch (Dali::DaliException e) {
31468       {
31469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31470       };
31471     } catch (...) {
31472       {
31473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31474       };
31475     }
31476   }
31477
31478   jresult = (void *)result;
31479   return jresult;
31480 }
31481
31482
31483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31484   void * jresult ;
31485   Dali::LongPressGestureDetector result;
31486
31487   {
31488     try {
31489       result = Dali::LongPressGestureDetector::New();
31490     } catch (std::out_of_range& e) {
31491       {
31492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31493       };
31494     } catch (std::exception& e) {
31495       {
31496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31497       };
31498     } catch (Dali::DaliException e) {
31499       {
31500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31501       };
31502     } catch (...) {
31503       {
31504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31505       };
31506     }
31507   }
31508
31509   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31510   return jresult;
31511 }
31512
31513
31514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31515   void * jresult ;
31516   unsigned int arg1 ;
31517   Dali::LongPressGestureDetector result;
31518
31519   arg1 = (unsigned int)jarg1;
31520   {
31521     try {
31522       result = Dali::LongPressGestureDetector::New(arg1);
31523     } catch (std::out_of_range& e) {
31524       {
31525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31526       };
31527     } catch (std::exception& e) {
31528       {
31529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31530       };
31531     } catch (Dali::DaliException e) {
31532       {
31533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31534       };
31535     } catch (...) {
31536       {
31537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31538       };
31539     }
31540   }
31541
31542   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31543   return jresult;
31544 }
31545
31546
31547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31548   void * jresult ;
31549   unsigned int arg1 ;
31550   unsigned int arg2 ;
31551   Dali::LongPressGestureDetector result;
31552
31553   arg1 = (unsigned int)jarg1;
31554   arg2 = (unsigned int)jarg2;
31555   {
31556     try {
31557       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31558     } catch (std::out_of_range& e) {
31559       {
31560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31561       };
31562     } catch (std::exception& e) {
31563       {
31564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31565       };
31566     } catch (Dali::DaliException e) {
31567       {
31568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31569       };
31570     } catch (...) {
31571       {
31572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31573       };
31574     }
31575   }
31576
31577   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31578   return jresult;
31579 }
31580
31581
31582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31583   void * jresult ;
31584   Dali::BaseHandle arg1 ;
31585   Dali::BaseHandle *argp1 ;
31586   Dali::LongPressGestureDetector result;
31587
31588   argp1 = (Dali::BaseHandle *)jarg1;
31589   if (!argp1) {
31590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31591     return 0;
31592   }
31593   arg1 = *argp1;
31594   {
31595     try {
31596       result = Dali::LongPressGestureDetector::DownCast(arg1);
31597     } catch (std::out_of_range& e) {
31598       {
31599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31600       };
31601     } catch (std::exception& e) {
31602       {
31603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31604       };
31605     } catch (Dali::DaliException e) {
31606       {
31607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31608       };
31609     } catch (...) {
31610       {
31611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31612       };
31613     }
31614   }
31615
31616   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31617   return jresult;
31618 }
31619
31620
31621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31622   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31623
31624   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31625   {
31626     try {
31627       delete arg1;
31628     } catch (std::out_of_range& e) {
31629       {
31630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31631       };
31632     } catch (std::exception& e) {
31633       {
31634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31635       };
31636     } catch (Dali::DaliException e) {
31637       {
31638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31639       };
31640     } catch (...) {
31641       {
31642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31643       };
31644     }
31645   }
31646
31647 }
31648
31649
31650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31651   void * jresult ;
31652   Dali::LongPressGestureDetector *arg1 = 0 ;
31653   Dali::LongPressGestureDetector *result = 0 ;
31654
31655   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31656   if (!arg1) {
31657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31658     return 0;
31659   }
31660   {
31661     try {
31662       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31663     } catch (std::out_of_range& e) {
31664       {
31665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31666       };
31667     } catch (std::exception& e) {
31668       {
31669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31670       };
31671     } catch (Dali::DaliException e) {
31672       {
31673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31674       };
31675     } catch (...) {
31676       {
31677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31678       };
31679     }
31680   }
31681
31682   jresult = (void *)result;
31683   return jresult;
31684 }
31685
31686
31687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31688   void * jresult ;
31689   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31690   Dali::LongPressGestureDetector *arg2 = 0 ;
31691   Dali::LongPressGestureDetector *result = 0 ;
31692
31693   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31694   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31695   if (!arg2) {
31696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31697     return 0;
31698   }
31699   {
31700     try {
31701       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31702     } catch (std::out_of_range& e) {
31703       {
31704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31705       };
31706     } catch (std::exception& e) {
31707       {
31708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (Dali::DaliException e) {
31711       {
31712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31713       };
31714     } catch (...) {
31715       {
31716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31717       };
31718     }
31719   }
31720
31721   jresult = (void *)result;
31722   return jresult;
31723 }
31724
31725
31726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31727   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31728   unsigned int arg2 ;
31729
31730   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31731   arg2 = (unsigned int)jarg2;
31732   {
31733     try {
31734       (arg1)->SetTouchesRequired(arg2);
31735     } catch (std::out_of_range& e) {
31736       {
31737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31738       };
31739     } catch (std::exception& e) {
31740       {
31741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31742       };
31743     } catch (Dali::DaliException e) {
31744       {
31745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31746       };
31747     } catch (...) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31750       };
31751     }
31752   }
31753
31754 }
31755
31756
31757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31758   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31759   unsigned int arg2 ;
31760   unsigned int arg3 ;
31761
31762   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31763   arg2 = (unsigned int)jarg2;
31764   arg3 = (unsigned int)jarg3;
31765   {
31766     try {
31767       (arg1)->SetTouchesRequired(arg2,arg3);
31768     } catch (std::out_of_range& e) {
31769       {
31770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31771       };
31772     } catch (std::exception& e) {
31773       {
31774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31775       };
31776     } catch (Dali::DaliException e) {
31777       {
31778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31779       };
31780     } catch (...) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31783       };
31784     }
31785   }
31786
31787 }
31788
31789
31790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31791   unsigned int jresult ;
31792   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31793   unsigned int result;
31794
31795   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31796   {
31797     try {
31798       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31799     } catch (std::out_of_range& e) {
31800       {
31801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31802       };
31803     } catch (std::exception& e) {
31804       {
31805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31806       };
31807     } catch (Dali::DaliException e) {
31808       {
31809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31810       };
31811     } catch (...) {
31812       {
31813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31814       };
31815     }
31816   }
31817
31818   jresult = result;
31819   return jresult;
31820 }
31821
31822
31823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31824   unsigned int jresult ;
31825   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31826   unsigned int result;
31827
31828   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31829   {
31830     try {
31831       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31832     } catch (std::out_of_range& e) {
31833       {
31834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31835       };
31836     } catch (std::exception& e) {
31837       {
31838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31839       };
31840     } catch (Dali::DaliException e) {
31841       {
31842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31843       };
31844     } catch (...) {
31845       {
31846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31847       };
31848     }
31849   }
31850
31851   jresult = result;
31852   return jresult;
31853 }
31854
31855
31856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31857   void * jresult ;
31858   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31859   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31860
31861   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31862   {
31863     try {
31864       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31865     } catch (std::out_of_range& e) {
31866       {
31867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31868       };
31869     } catch (std::exception& e) {
31870       {
31871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31872       };
31873     } catch (Dali::DaliException e) {
31874       {
31875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31876       };
31877     } catch (...) {
31878       {
31879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31880       };
31881     }
31882   }
31883
31884   jresult = (void *)result;
31885   return jresult;
31886 }
31887
31888
31889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31890   void * jresult ;
31891   Dali::Gesture::State arg1 ;
31892   Dali::LongPressGesture *result = 0 ;
31893
31894   arg1 = (Dali::Gesture::State)jarg1;
31895   {
31896     try {
31897       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31898     } catch (std::out_of_range& e) {
31899       {
31900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31901       };
31902     } catch (std::exception& e) {
31903       {
31904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31905       };
31906     } catch (Dali::DaliException e) {
31907       {
31908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31909       };
31910     } catch (...) {
31911       {
31912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31913       };
31914     }
31915   }
31916
31917   jresult = (void *)result;
31918   return jresult;
31919 }
31920
31921
31922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31923   void * jresult ;
31924   Dali::LongPressGesture *arg1 = 0 ;
31925   Dali::LongPressGesture *result = 0 ;
31926
31927   arg1 = (Dali::LongPressGesture *)jarg1;
31928   if (!arg1) {
31929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31930     return 0;
31931   }
31932   {
31933     try {
31934       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31935     } catch (std::out_of_range& e) {
31936       {
31937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31938       };
31939     } catch (std::exception& e) {
31940       {
31941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31942       };
31943     } catch (Dali::DaliException e) {
31944       {
31945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31946       };
31947     } catch (...) {
31948       {
31949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31950       };
31951     }
31952   }
31953
31954   jresult = (void *)result;
31955   return jresult;
31956 }
31957
31958
31959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31960   void * jresult ;
31961   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31962   Dali::LongPressGesture *arg2 = 0 ;
31963   Dali::LongPressGesture *result = 0 ;
31964
31965   arg1 = (Dali::LongPressGesture *)jarg1;
31966   arg2 = (Dali::LongPressGesture *)jarg2;
31967   if (!arg2) {
31968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31969     return 0;
31970   }
31971   {
31972     try {
31973       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31974     } catch (std::out_of_range& e) {
31975       {
31976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31977       };
31978     } catch (std::exception& e) {
31979       {
31980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31981       };
31982     } catch (Dali::DaliException e) {
31983       {
31984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31985       };
31986     } catch (...) {
31987       {
31988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31989       };
31990     }
31991   }
31992
31993   jresult = (void *)result;
31994   return jresult;
31995 }
31996
31997
31998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31999   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32000
32001   arg1 = (Dali::LongPressGesture *)jarg1;
32002   {
32003     try {
32004       delete arg1;
32005     } catch (std::out_of_range& e) {
32006       {
32007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32008       };
32009     } catch (std::exception& e) {
32010       {
32011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32012       };
32013     } catch (Dali::DaliException e) {
32014       {
32015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32016       };
32017     } catch (...) {
32018       {
32019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32020       };
32021     }
32022   }
32023
32024 }
32025
32026
32027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32028   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32029   unsigned int arg2 ;
32030
32031   arg1 = (Dali::LongPressGesture *)jarg1;
32032   arg2 = (unsigned int)jarg2;
32033   if (arg1) (arg1)->numberOfTouches = arg2;
32034 }
32035
32036
32037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32038   unsigned int jresult ;
32039   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32040   unsigned int result;
32041
32042   arg1 = (Dali::LongPressGesture *)jarg1;
32043   result = (unsigned int) ((arg1)->numberOfTouches);
32044   jresult = result;
32045   return jresult;
32046 }
32047
32048
32049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32050   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32051   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32052
32053   arg1 = (Dali::LongPressGesture *)jarg1;
32054   arg2 = (Dali::Vector2 *)jarg2;
32055   if (arg1) (arg1)->screenPoint = *arg2;
32056 }
32057
32058
32059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32060   void * jresult ;
32061   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32062   Dali::Vector2 *result = 0 ;
32063
32064   arg1 = (Dali::LongPressGesture *)jarg1;
32065   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32066   jresult = (void *)result;
32067   return jresult;
32068 }
32069
32070
32071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32072   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32073   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32074
32075   arg1 = (Dali::LongPressGesture *)jarg1;
32076   arg2 = (Dali::Vector2 *)jarg2;
32077   if (arg1) (arg1)->localPoint = *arg2;
32078 }
32079
32080
32081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32082   void * jresult ;
32083   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32084   Dali::Vector2 *result = 0 ;
32085
32086   arg1 = (Dali::LongPressGesture *)jarg1;
32087   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32088   jresult = (void *)result;
32089   return jresult;
32090 }
32091
32092
32093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32094   void * jresult ;
32095   Dali::WheelEvent *result = 0 ;
32096
32097   {
32098     try {
32099       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32100     } catch (std::out_of_range& e) {
32101       {
32102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32103       };
32104     } catch (std::exception& e) {
32105       {
32106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32107       };
32108     } catch (Dali::DaliException e) {
32109       {
32110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32111       };
32112     } catch (...) {
32113       {
32114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32115       };
32116     }
32117   }
32118
32119   jresult = (void *)result;
32120   return jresult;
32121 }
32122
32123
32124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32125   void * jresult ;
32126   Dali::WheelEvent::Type arg1 ;
32127   int arg2 ;
32128   unsigned int arg3 ;
32129   Dali::Vector2 arg4 ;
32130   int arg5 ;
32131   unsigned int arg6 ;
32132   Dali::Vector2 *argp4 ;
32133   Dali::WheelEvent *result = 0 ;
32134
32135   arg1 = (Dali::WheelEvent::Type)jarg1;
32136   arg2 = (int)jarg2;
32137   arg3 = (unsigned int)jarg3;
32138   argp4 = (Dali::Vector2 *)jarg4;
32139   if (!argp4) {
32140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32141     return 0;
32142   }
32143   arg4 = *argp4;
32144   arg5 = (int)jarg5;
32145   arg6 = (unsigned int)jarg6;
32146   {
32147     try {
32148       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32149     } catch (std::out_of_range& e) {
32150       {
32151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32152       };
32153     } catch (std::exception& e) {
32154       {
32155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32156       };
32157     } catch (Dali::DaliException e) {
32158       {
32159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32160       };
32161     } catch (...) {
32162       {
32163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32164       };
32165     }
32166   }
32167
32168   jresult = (void *)result;
32169   return jresult;
32170 }
32171
32172
32173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32174   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32175
32176   arg1 = (Dali::WheelEvent *)jarg1;
32177   {
32178     try {
32179       delete arg1;
32180     } catch (std::out_of_range& e) {
32181       {
32182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32183       };
32184     } catch (std::exception& e) {
32185       {
32186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32187       };
32188     } catch (Dali::DaliException e) {
32189       {
32190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32191       };
32192     } catch (...) {
32193       {
32194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32195       };
32196     }
32197   }
32198
32199 }
32200
32201
32202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32203   unsigned int jresult ;
32204   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32205   bool result;
32206
32207   arg1 = (Dali::WheelEvent *)jarg1;
32208   {
32209     try {
32210       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32211     } catch (std::out_of_range& e) {
32212       {
32213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32214       };
32215     } catch (std::exception& e) {
32216       {
32217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32218       };
32219     } catch (Dali::DaliException e) {
32220       {
32221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32222       };
32223     } catch (...) {
32224       {
32225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32226       };
32227     }
32228   }
32229
32230   jresult = result;
32231   return jresult;
32232 }
32233
32234
32235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32236   unsigned int jresult ;
32237   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32238   bool result;
32239
32240   arg1 = (Dali::WheelEvent *)jarg1;
32241   {
32242     try {
32243       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32244     } catch (std::out_of_range& e) {
32245       {
32246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32247       };
32248     } catch (std::exception& e) {
32249       {
32250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32251       };
32252     } catch (Dali::DaliException e) {
32253       {
32254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32255       };
32256     } catch (...) {
32257       {
32258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32259       };
32260     }
32261   }
32262
32263   jresult = result;
32264   return jresult;
32265 }
32266
32267
32268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32269   unsigned int jresult ;
32270   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32271   bool result;
32272
32273   arg1 = (Dali::WheelEvent *)jarg1;
32274   {
32275     try {
32276       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32277     } catch (std::out_of_range& e) {
32278       {
32279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32280       };
32281     } catch (std::exception& e) {
32282       {
32283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32284       };
32285     } catch (Dali::DaliException e) {
32286       {
32287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32288       };
32289     } catch (...) {
32290       {
32291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32292       };
32293     }
32294   }
32295
32296   jresult = result;
32297   return jresult;
32298 }
32299
32300
32301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32302   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32303   Dali::WheelEvent::Type arg2 ;
32304
32305   arg1 = (Dali::WheelEvent *)jarg1;
32306   arg2 = (Dali::WheelEvent::Type)jarg2;
32307   if (arg1) (arg1)->type = arg2;
32308 }
32309
32310
32311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32312   int jresult ;
32313   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32314   Dali::WheelEvent::Type result;
32315
32316   arg1 = (Dali::WheelEvent *)jarg1;
32317   result = (Dali::WheelEvent::Type) ((arg1)->type);
32318   jresult = (int)result;
32319   return jresult;
32320 }
32321
32322
32323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32324   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32325   int arg2 ;
32326
32327   arg1 = (Dali::WheelEvent *)jarg1;
32328   arg2 = (int)jarg2;
32329   if (arg1) (arg1)->direction = arg2;
32330 }
32331
32332
32333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32334   int jresult ;
32335   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32336   int result;
32337
32338   arg1 = (Dali::WheelEvent *)jarg1;
32339   result = (int) ((arg1)->direction);
32340   jresult = result;
32341   return jresult;
32342 }
32343
32344
32345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32346   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32347   unsigned int arg2 ;
32348
32349   arg1 = (Dali::WheelEvent *)jarg1;
32350   arg2 = (unsigned int)jarg2;
32351   if (arg1) (arg1)->modifiers = arg2;
32352 }
32353
32354
32355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32356   unsigned int jresult ;
32357   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32358   unsigned int result;
32359
32360   arg1 = (Dali::WheelEvent *)jarg1;
32361   result = (unsigned int) ((arg1)->modifiers);
32362   jresult = result;
32363   return jresult;
32364 }
32365
32366
32367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32368   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32369   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32370
32371   arg1 = (Dali::WheelEvent *)jarg1;
32372   arg2 = (Dali::Vector2 *)jarg2;
32373   if (arg1) (arg1)->point = *arg2;
32374 }
32375
32376
32377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32378   void * jresult ;
32379   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32380   Dali::Vector2 *result = 0 ;
32381
32382   arg1 = (Dali::WheelEvent *)jarg1;
32383   result = (Dali::Vector2 *)& ((arg1)->point);
32384   jresult = (void *)result;
32385   return jresult;
32386 }
32387
32388
32389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32390   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32391   int arg2 ;
32392
32393   arg1 = (Dali::WheelEvent *)jarg1;
32394   arg2 = (int)jarg2;
32395   if (arg1) (arg1)->z = arg2;
32396 }
32397
32398
32399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32400   int jresult ;
32401   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32402   int result;
32403
32404   arg1 = (Dali::WheelEvent *)jarg1;
32405   result = (int) ((arg1)->z);
32406   jresult = result;
32407   return jresult;
32408 }
32409
32410
32411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32412   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32413   unsigned int arg2 ;
32414
32415   arg1 = (Dali::WheelEvent *)jarg1;
32416   arg2 = (unsigned int)jarg2;
32417   if (arg1) (arg1)->timeStamp = arg2;
32418 }
32419
32420
32421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32422   unsigned int jresult ;
32423   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32424   unsigned int result;
32425
32426   arg1 = (Dali::WheelEvent *)jarg1;
32427   result = (unsigned int) ((arg1)->timeStamp);
32428   jresult = result;
32429   return jresult;
32430 }
32431
32432 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32433   char * jresult ;
32434   Dali::KeyEvent *arg1 = 0 ;
32435   std::string result;
32436
32437   arg1 = (Dali::KeyEvent *)jarg1;
32438   if (!arg1) {
32439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32440     return 0;
32441   }
32442   {
32443     try {
32444       result = arg1->GetDeviceName();
32445     } catch (std::out_of_range& e) {
32446       {
32447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32448       };
32449     } catch (std::exception& e) {
32450       {
32451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32452       };
32453     } catch (Dali::DaliException e) {
32454       {
32455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32456       };
32457     } catch (...) {
32458       {
32459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32460       };
32461     }
32462   }
32463
32464   jresult = SWIG_csharp_string_callback((&result)->c_str());
32465   return jresult;
32466 }
32467
32468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32469   int jresult ;
32470   Dali::KeyEvent *arg1 = 0 ;
32471   Dali::Device::Class::Type result;
32472
32473   arg1 = (Dali::KeyEvent *)jarg1;
32474   if (!arg1) {
32475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32476     return 0;
32477   }
32478   {
32479     try {
32480       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32481     } catch (std::out_of_range& e) {
32482       {
32483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32484       };
32485     } catch (std::exception& e) {
32486       {
32487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32488       };
32489     } catch (Dali::DaliException e) {
32490       {
32491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32492       };
32493     } catch (...) {
32494       {
32495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32496       };
32497     }
32498   }
32499
32500   jresult = (int)result;
32501   return jresult;
32502 }
32503
32504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32505   int jresult ;
32506   Dali::KeyEvent *arg1 = 0 ;
32507   Dali::Device::Subclass::Type result;
32508
32509   arg1 = (Dali::KeyEvent *)jarg1;
32510   if (!arg1) {
32511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32512     return 0;
32513   }
32514   {
32515     try {
32516       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32517     } catch (std::out_of_range& e) {
32518       {
32519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32520       };
32521     } catch (std::exception& e) {
32522       {
32523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32524       };
32525     } catch (Dali::DaliException e) {
32526       {
32527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32528       };
32529     } catch (...) {
32530       {
32531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32532       };
32533     }
32534   }
32535
32536   jresult = (int)result;
32537   return jresult;
32538 }
32539
32540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32541   Dali::Actor arg1 ;
32542   Dali::Actor *argp1 ;
32543
32544   argp1 = (Dali::Actor *)jarg1;
32545   if (!argp1) {
32546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32547     return ;
32548   }
32549   arg1 = *argp1;
32550   {
32551     try {
32552       arg1.Raise();
32553     } catch (std::out_of_range& e) {
32554       {
32555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32556       };
32557     } catch (std::exception& e) {
32558       {
32559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32560       };
32561     } catch (Dali::DaliException e) {
32562       {
32563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32564       };
32565     } catch (...) {
32566       {
32567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32568       };
32569     }
32570   }
32571
32572 }
32573
32574
32575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32576   Dali::Actor arg1 ;
32577   Dali::Actor *argp1 ;
32578
32579   argp1 = (Dali::Actor *)jarg1;
32580   if (!argp1) {
32581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32582     return ;
32583   }
32584   arg1 = *argp1;
32585   {
32586     try {
32587       arg1.Lower();
32588     } catch (std::out_of_range& e) {
32589       {
32590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32591       };
32592     } catch (std::exception& e) {
32593       {
32594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32595       };
32596     } catch (Dali::DaliException e) {
32597       {
32598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32599       };
32600     } catch (...) {
32601       {
32602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32603       };
32604     }
32605   }
32606
32607 }
32608
32609
32610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32611   Dali::Actor arg1 ;
32612   Dali::Actor *argp1 ;
32613
32614   argp1 = (Dali::Actor *)jarg1;
32615   if (!argp1) {
32616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32617     return ;
32618   }
32619   arg1 = *argp1;
32620   {
32621     try {
32622       arg1.RaiseToTop();
32623     } catch (std::out_of_range& e) {
32624       {
32625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32626       };
32627     } catch (std::exception& e) {
32628       {
32629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32630       };
32631     } catch (Dali::DaliException e) {
32632       {
32633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32634       };
32635     } catch (...) {
32636       {
32637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32638       };
32639     }
32640   }
32641
32642 }
32643
32644
32645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32646   Dali::Actor arg1 ;
32647   Dali::Actor *argp1 ;
32648
32649   argp1 = (Dali::Actor *)jarg1;
32650   if (!argp1) {
32651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32652     return ;
32653   }
32654   arg1 = *argp1;
32655   {
32656     try {
32657       arg1.LowerToBottom();
32658     } catch (std::out_of_range& e) {
32659       {
32660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32661       };
32662     } catch (std::exception& e) {
32663       {
32664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32665       };
32666     } catch (Dali::DaliException e) {
32667       {
32668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32669       };
32670     } catch (...) {
32671       {
32672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32673       };
32674     }
32675   }
32676
32677 }
32678
32679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32680   Dali::Actor arg1 ;
32681   Dali::Actor arg2 ;
32682   Dali::Actor *argp1 ;
32683   Dali::Actor *argp2 ;
32684
32685   argp1 = (Dali::Actor *)jarg1;
32686   if (!argp1) {
32687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32688     return ;
32689   }
32690   arg1 = *argp1;
32691   argp2 = (Dali::Actor *)jarg2;
32692   if (!argp2) {
32693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32694     return ;
32695   }
32696   arg2 = *argp2;
32697   {
32698     try {
32699       arg1.RaiseAbove(arg2);
32700     } catch (std::out_of_range& e) {
32701       {
32702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32703       };
32704     } catch (std::exception& e) {
32705       {
32706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32707       };
32708     } catch (Dali::DaliException e) {
32709       {
32710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32711       };
32712     } catch (...) {
32713       {
32714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32715       };
32716     }
32717   }
32718
32719 }
32720
32721
32722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32723   Dali::Actor arg1 ;
32724   Dali::Actor arg2 ;
32725   Dali::Actor *argp1 ;
32726   Dali::Actor *argp2 ;
32727
32728   argp1 = (Dali::Actor *)jarg1;
32729   if (!argp1) {
32730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32731     return ;
32732   }
32733   arg1 = *argp1;
32734   argp2 = (Dali::Actor *)jarg2;
32735   if (!argp2) {
32736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32737     return ;
32738   }
32739   arg2 = *argp2;
32740   {
32741     try {
32742       arg1.LowerBelow(arg2);
32743     } catch (std::out_of_range& e) {
32744       {
32745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32746       };
32747     } catch (std::exception& e) {
32748       {
32749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32750       };
32751     } catch (Dali::DaliException e) {
32752       {
32753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32754       };
32755     } catch (...) {
32756       {
32757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32758       };
32759     }
32760   }
32761
32762 }
32763
32764
32765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32766   void * jresult ;
32767   Dali::Actor arg1 ;
32768   Dali::Actor *argp1 ;
32769   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32770
32771   argp1 = (Dali::Actor *)jarg1;
32772   if (!argp1) {
32773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32774     return 0;
32775   }
32776   arg1 = *argp1;
32777   {
32778     try {
32779       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32780     } catch (std::out_of_range& e) {
32781       {
32782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32783       };
32784     } catch (std::exception& e) {
32785       {
32786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32787       };
32788     } catch (Dali::DaliException e) {
32789       {
32790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32791       };
32792     } catch (...) {
32793       {
32794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32795       };
32796     }
32797   }
32798
32799   jresult = (void *)result;
32800   return jresult;
32801 }
32802
32803
32804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32805   void * jresult ;
32806   Dali::Actor *arg1 ;
32807   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32808
32809   arg1 = (Dali::Actor *)jarg1;
32810   {
32811     try {
32812       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32813     } catch (std::out_of_range& e) {
32814       {
32815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32816       };
32817     } catch (std::exception& e) {
32818       {
32819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32820       };
32821     } catch (Dali::DaliException e) {
32822       {
32823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32824       };
32825     } catch (...) {
32826       {
32827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32828       };
32829     }
32830   }
32831
32832   jresult = (void *)result;
32833   return jresult;
32834 }
32835
32836
32837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32838   int jresult ;
32839   int result;
32840
32841   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32842   jresult = (int)result;
32843   return jresult;
32844 }
32845
32846
32847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32848   int jresult ;
32849   int result;
32850
32851   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32852   jresult = (int)result;
32853   return jresult;
32854 }
32855
32856
32857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32858   int jresult ;
32859   int result;
32860
32861   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32862   jresult = (int)result;
32863   return jresult;
32864 }
32865
32866
32867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32868   int jresult ;
32869   int result;
32870
32871   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32872   jresult = (int)result;
32873   return jresult;
32874 }
32875
32876
32877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32878   int jresult ;
32879   int result;
32880
32881   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32882   jresult = (int)result;
32883   return jresult;
32884 }
32885
32886
32887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32888   int jresult ;
32889   int result;
32890
32891   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32892   jresult = (int)result;
32893   return jresult;
32894 }
32895
32896
32897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32898   int jresult ;
32899   int result;
32900
32901   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32902   jresult = (int)result;
32903   return jresult;
32904 }
32905
32906
32907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32908   int jresult ;
32909   int result;
32910
32911   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32912   jresult = (int)result;
32913   return jresult;
32914 }
32915
32916
32917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32918   int jresult ;
32919   int result;
32920
32921   result = (int)Dali::Actor::Property::SIZE;
32922   jresult = (int)result;
32923   return jresult;
32924 }
32925
32926
32927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32928   int jresult ;
32929   int result;
32930
32931   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32932   jresult = (int)result;
32933   return jresult;
32934 }
32935
32936
32937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32938   int jresult ;
32939   int result;
32940
32941   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32942   jresult = (int)result;
32943   return jresult;
32944 }
32945
32946
32947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32948   int jresult ;
32949   int result;
32950
32951   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32952   jresult = (int)result;
32953   return jresult;
32954 }
32955
32956
32957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32958   int jresult ;
32959   int result;
32960
32961   result = (int)Dali::Actor::Property::POSITION;
32962   jresult = (int)result;
32963   return jresult;
32964 }
32965
32966
32967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32968   int jresult ;
32969   int result;
32970
32971   result = (int)Dali::Actor::Property::POSITION_X;
32972   jresult = (int)result;
32973   return jresult;
32974 }
32975
32976
32977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32978   int jresult ;
32979   int result;
32980
32981   result = (int)Dali::Actor::Property::POSITION_Y;
32982   jresult = (int)result;
32983   return jresult;
32984 }
32985
32986
32987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32988   int jresult ;
32989   int result;
32990
32991   result = (int)Dali::Actor::Property::POSITION_Z;
32992   jresult = (int)result;
32993   return jresult;
32994 }
32995
32996
32997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32998   int jresult ;
32999   int result;
33000
33001   result = (int)Dali::Actor::Property::WORLD_POSITION;
33002   jresult = (int)result;
33003   return jresult;
33004 }
33005
33006
33007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33008   int jresult ;
33009   int result;
33010
33011   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33012   jresult = (int)result;
33013   return jresult;
33014 }
33015
33016
33017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33018   int jresult ;
33019   int result;
33020
33021   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33022   jresult = (int)result;
33023   return jresult;
33024 }
33025
33026
33027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33028   int jresult ;
33029   int result;
33030
33031   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33032   jresult = (int)result;
33033   return jresult;
33034 }
33035
33036
33037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33038   int jresult ;
33039   int result;
33040
33041   result = (int)Dali::Actor::Property::ORIENTATION;
33042   jresult = (int)result;
33043   return jresult;
33044 }
33045
33046
33047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33048   int jresult ;
33049   int result;
33050
33051   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33052   jresult = (int)result;
33053   return jresult;
33054 }
33055
33056
33057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33058   int jresult ;
33059   int result;
33060
33061   result = (int)Dali::Actor::Property::SCALE;
33062   jresult = (int)result;
33063   return jresult;
33064 }
33065
33066
33067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33068   int jresult ;
33069   int result;
33070
33071   result = (int)Dali::Actor::Property::SCALE_X;
33072   jresult = (int)result;
33073   return jresult;
33074 }
33075
33076
33077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33078   int jresult ;
33079   int result;
33080
33081   result = (int)Dali::Actor::Property::SCALE_Y;
33082   jresult = (int)result;
33083   return jresult;
33084 }
33085
33086
33087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33088   int jresult ;
33089   int result;
33090
33091   result = (int)Dali::Actor::Property::SCALE_Z;
33092   jresult = (int)result;
33093   return jresult;
33094 }
33095
33096
33097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33098   int jresult ;
33099   int result;
33100
33101   result = (int)Dali::Actor::Property::WORLD_SCALE;
33102   jresult = (int)result;
33103   return jresult;
33104 }
33105
33106
33107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33108   int jresult ;
33109   int result;
33110
33111   result = (int)Dali::Actor::Property::VISIBLE;
33112   jresult = (int)result;
33113   return jresult;
33114 }
33115
33116
33117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33118   int jresult ;
33119   int result;
33120
33121   result = (int)Dali::Actor::Property::COLOR;
33122   jresult = (int)result;
33123   return jresult;
33124 }
33125
33126
33127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33128   int jresult ;
33129   int result;
33130
33131   result = (int)Dali::Actor::Property::COLOR_RED;
33132   jresult = (int)result;
33133   return jresult;
33134 }
33135
33136
33137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33138   int jresult ;
33139   int result;
33140
33141   result = (int)Dali::Actor::Property::COLOR_GREEN;
33142   jresult = (int)result;
33143   return jresult;
33144 }
33145
33146
33147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33148   int jresult ;
33149   int result;
33150
33151   result = (int)Dali::Actor::Property::COLOR_BLUE;
33152   jresult = (int)result;
33153   return jresult;
33154 }
33155
33156
33157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33158   int jresult ;
33159   int result;
33160
33161   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33162   jresult = (int)result;
33163   return jresult;
33164 }
33165
33166
33167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33168   int jresult ;
33169   int result;
33170
33171   result = (int)Dali::Actor::Property::WORLD_COLOR;
33172   jresult = (int)result;
33173   return jresult;
33174 }
33175
33176
33177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33178   int jresult ;
33179   int result;
33180
33181   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33182   jresult = (int)result;
33183   return jresult;
33184 }
33185
33186
33187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33188   int jresult ;
33189   int result;
33190
33191   result = (int)Dali::Actor::Property::NAME;
33192   jresult = (int)result;
33193   return jresult;
33194 }
33195
33196
33197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33198   int jresult ;
33199   int result;
33200
33201   result = (int)Dali::Actor::Property::SENSITIVE;
33202   jresult = (int)result;
33203   return jresult;
33204 }
33205
33206
33207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33208   int jresult ;
33209   int result;
33210
33211   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33212   jresult = (int)result;
33213   return jresult;
33214 }
33215
33216
33217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33218   int jresult ;
33219   int result;
33220
33221   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33222   jresult = (int)result;
33223   return jresult;
33224 }
33225
33226
33227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33228   int jresult ;
33229   int result;
33230
33231   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33232   jresult = (int)result;
33233   return jresult;
33234 }
33235
33236
33237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33238   int jresult ;
33239   int result;
33240
33241   result = (int)Dali::Actor::Property::COLOR_MODE;
33242   jresult = (int)result;
33243   return jresult;
33244 }
33245
33246
33247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33248   int jresult ;
33249   int result;
33250
33251   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33252   jresult = (int)result;
33253   return jresult;
33254 }
33255
33256
33257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33258   int jresult ;
33259   int result;
33260
33261   result = (int)Dali::Actor::Property::DRAW_MODE;
33262   jresult = (int)result;
33263   return jresult;
33264 }
33265
33266
33267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33268   int jresult ;
33269   int result;
33270
33271   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33272   jresult = (int)result;
33273   return jresult;
33274 }
33275
33276
33277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33278   int jresult ;
33279   int result;
33280
33281   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33282   jresult = (int)result;
33283   return jresult;
33284 }
33285
33286
33287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33288   int jresult ;
33289   int result;
33290
33291   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33292   jresult = (int)result;
33293   return jresult;
33294 }
33295
33296
33297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33298   int jresult ;
33299   int result;
33300
33301   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33302   jresult = (int)result;
33303   return jresult;
33304 }
33305
33306
33307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33308   int jresult ;
33309   int result;
33310
33311   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33312   jresult = (int)result;
33313   return jresult;
33314 }
33315
33316
33317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33318   int jresult ;
33319   int result;
33320
33321   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33322   jresult = (int)result;
33323   return jresult;
33324 }
33325
33326
33327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33328   int jresult ;
33329   int result;
33330
33331   result = (int)Dali::Actor::Property::PADDING;
33332   jresult = (int)result;
33333   return jresult;
33334 }
33335
33336
33337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33338   int jresult ;
33339   int result;
33340
33341   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33342   jresult = (int)result;
33343   return jresult;
33344 }
33345
33346
33347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33348   int jresult ;
33349   int result;
33350
33351   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33352   jresult = (int)result;
33353   return jresult;
33354 }
33355
33356
33357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33358   int jresult ;
33359   int result;
33360
33361   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33362   jresult = (int)result;
33363   return jresult;
33364 }
33365
33366
33367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33368   int jresult ;
33369   int result;
33370
33371   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33372   jresult = (int)result;
33373   return jresult;
33374 }
33375
33376
33377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33378   void * jresult ;
33379   Dali::Actor::Property *result = 0 ;
33380
33381   {
33382     try {
33383       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33384     } catch (std::out_of_range& e) {
33385       {
33386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33387       };
33388     } catch (std::exception& e) {
33389       {
33390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33391       };
33392     } catch (Dali::DaliException e) {
33393       {
33394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33395       };
33396     } catch (...) {
33397       {
33398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33399       };
33400     }
33401   }
33402
33403   jresult = (void *)result;
33404   return jresult;
33405 }
33406
33407
33408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33409   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33410
33411   arg1 = (Dali::Actor::Property *)jarg1;
33412   {
33413     try {
33414       delete arg1;
33415     } catch (std::out_of_range& e) {
33416       {
33417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33418       };
33419     } catch (std::exception& e) {
33420       {
33421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33422       };
33423     } catch (Dali::DaliException e) {
33424       {
33425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33426       };
33427     } catch (...) {
33428       {
33429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33430       };
33431     }
33432   }
33433
33434 }
33435
33436
33437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33438   void * jresult ;
33439   Dali::Actor *result = 0 ;
33440
33441   {
33442     try {
33443       result = (Dali::Actor *)new Dali::Actor();
33444     } catch (std::out_of_range& e) {
33445       {
33446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33447       };
33448     } catch (std::exception& e) {
33449       {
33450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33451       };
33452     } catch (Dali::DaliException e) {
33453       {
33454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33455       };
33456     } catch (...) {
33457       {
33458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33459       };
33460     }
33461   }
33462
33463   jresult = (void *)result;
33464   return jresult;
33465 }
33466
33467
33468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33469   void * jresult ;
33470   Dali::Actor result;
33471
33472   {
33473     try {
33474       result = Dali::Actor::New();
33475     } catch (std::out_of_range& e) {
33476       {
33477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33478       };
33479     } catch (std::exception& e) {
33480       {
33481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33482       };
33483     } catch (Dali::DaliException e) {
33484       {
33485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33486       };
33487     } catch (...) {
33488       {
33489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33490       };
33491     }
33492   }
33493
33494   jresult = new Dali::Actor((const Dali::Actor &)result);
33495   return jresult;
33496 }
33497
33498
33499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33500   void * jresult ;
33501   Dali::BaseHandle arg1 ;
33502   Dali::BaseHandle *argp1 ;
33503   Dali::Actor result;
33504
33505   argp1 = (Dali::BaseHandle *)jarg1;
33506   if (!argp1) {
33507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33508     return 0;
33509   }
33510   arg1 = *argp1;
33511   {
33512     try {
33513       result = Dali::Actor::DownCast(arg1);
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 (Dali::DaliException e) {
33523       {
33524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33525       };
33526     } catch (...) {
33527       {
33528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33529       };
33530     }
33531   }
33532
33533   jresult = new Dali::Actor((const Dali::Actor &)result);
33534   return jresult;
33535 }
33536
33537
33538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33539   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33540
33541   arg1 = (Dali::Actor *)jarg1;
33542   {
33543     try {
33544       delete arg1;
33545     } catch (std::out_of_range& e) {
33546       {
33547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33548       };
33549     } catch (std::exception& e) {
33550       {
33551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33552       };
33553     } catch (Dali::DaliException e) {
33554       {
33555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33556       };
33557     } catch (...) {
33558       {
33559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33560       };
33561     }
33562   }
33563
33564 }
33565
33566
33567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33568   void * jresult ;
33569   Dali::Actor *arg1 = 0 ;
33570   Dali::Actor *result = 0 ;
33571
33572   arg1 = (Dali::Actor *)jarg1;
33573   if (!arg1) {
33574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33575     return 0;
33576   }
33577   {
33578     try {
33579       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33580     } catch (std::out_of_range& e) {
33581       {
33582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33583       };
33584     } catch (std::exception& e) {
33585       {
33586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33587       };
33588     } catch (Dali::DaliException e) {
33589       {
33590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33591       };
33592     } catch (...) {
33593       {
33594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33595       };
33596     }
33597   }
33598
33599   jresult = (void *)result;
33600   return jresult;
33601 }
33602
33603
33604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33605   void * jresult ;
33606   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33607   Dali::Actor *arg2 = 0 ;
33608   Dali::Actor *result = 0 ;
33609
33610   arg1 = (Dali::Actor *)jarg1;
33611   arg2 = (Dali::Actor *)jarg2;
33612   if (!arg2) {
33613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33614     return 0;
33615   }
33616   {
33617     try {
33618       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33619     } catch (std::out_of_range& e) {
33620       {
33621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33622       };
33623     } catch (std::exception& e) {
33624       {
33625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33626       };
33627     } catch (Dali::DaliException e) {
33628       {
33629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33630       };
33631     } catch (...) {
33632       {
33633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33634       };
33635     }
33636   }
33637
33638   jresult = (void *)result;
33639   return jresult;
33640 }
33641
33642
33643 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33644   char * jresult ;
33645   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33646   std::string *result = 0 ;
33647
33648   arg1 = (Dali::Actor *)jarg1;
33649   {
33650     try {
33651       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33652     } catch (std::out_of_range& e) {
33653       {
33654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33655       };
33656     } catch (std::exception& e) {
33657       {
33658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33659       };
33660     } catch (Dali::DaliException e) {
33661       {
33662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33663       };
33664     } catch (...) {
33665       {
33666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33667       };
33668     }
33669   }
33670
33671   jresult = SWIG_csharp_string_callback(result->c_str());
33672   return jresult;
33673 }
33674
33675
33676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33677   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33678   std::string *arg2 = 0 ;
33679
33680   arg1 = (Dali::Actor *)jarg1;
33681   if (!jarg2) {
33682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33683     return ;
33684   }
33685   std::string arg2_str(jarg2);
33686   arg2 = &arg2_str;
33687   {
33688     try {
33689       (arg1)->SetName((std::string const &)*arg2);
33690     } catch (std::out_of_range& e) {
33691       {
33692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33693       };
33694     } catch (std::exception& e) {
33695       {
33696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33697       };
33698     } catch (Dali::DaliException e) {
33699       {
33700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33701       };
33702     } catch (...) {
33703       {
33704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33705       };
33706     }
33707   }
33708
33709
33710   //argout typemap for const std::string&
33711
33712 }
33713
33714
33715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33716   unsigned int jresult ;
33717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33718   unsigned int result;
33719
33720   arg1 = (Dali::Actor *)jarg1;
33721   {
33722     try {
33723       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33724     } catch (std::out_of_range& e) {
33725       {
33726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33727       };
33728     } catch (std::exception& e) {
33729       {
33730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33731       };
33732     } catch (Dali::DaliException e) {
33733       {
33734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33735       };
33736     } catch (...) {
33737       {
33738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33739       };
33740     }
33741   }
33742
33743   jresult = result;
33744   return jresult;
33745 }
33746
33747
33748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33749   unsigned int jresult ;
33750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33751   bool result;
33752
33753   arg1 = (Dali::Actor *)jarg1;
33754   {
33755     try {
33756       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33757     } catch (std::out_of_range& e) {
33758       {
33759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33760       };
33761     } catch (std::exception& e) {
33762       {
33763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33764       };
33765     } catch (Dali::DaliException e) {
33766       {
33767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33768       };
33769     } catch (...) {
33770       {
33771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33772       };
33773     }
33774   }
33775
33776   jresult = result;
33777   return jresult;
33778 }
33779
33780
33781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33782   unsigned int jresult ;
33783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33784   bool result;
33785
33786   arg1 = (Dali::Actor *)jarg1;
33787   {
33788     try {
33789       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33790     } catch (std::out_of_range& e) {
33791       {
33792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33793       };
33794     } catch (std::exception& e) {
33795       {
33796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33797       };
33798     } catch (Dali::DaliException e) {
33799       {
33800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33801       };
33802     } catch (...) {
33803       {
33804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33805       };
33806     }
33807   }
33808
33809   jresult = result;
33810   return jresult;
33811 }
33812
33813
33814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33815   unsigned int jresult ;
33816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33817   bool result;
33818
33819   arg1 = (Dali::Actor *)jarg1;
33820   {
33821     try {
33822       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33823     } catch (std::out_of_range& e) {
33824       {
33825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33826       };
33827     } catch (std::exception& e) {
33828       {
33829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33830       };
33831     } catch (Dali::DaliException e) {
33832       {
33833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33834       };
33835     } catch (...) {
33836       {
33837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33838       };
33839     }
33840   }
33841
33842   jresult = result;
33843   return jresult;
33844 }
33845
33846
33847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33848   void * jresult ;
33849   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33850   Dali::Layer result;
33851
33852   arg1 = (Dali::Actor *)jarg1;
33853   {
33854     try {
33855       result = (arg1)->GetLayer();
33856     } catch (std::out_of_range& e) {
33857       {
33858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33859       };
33860     } catch (std::exception& e) {
33861       {
33862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33863       };
33864     } catch (Dali::DaliException e) {
33865       {
33866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33867       };
33868     } catch (...) {
33869       {
33870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33871       };
33872     }
33873   }
33874
33875   jresult = new Dali::Layer((const Dali::Layer &)result);
33876   return jresult;
33877 }
33878
33879
33880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33882   Dali::Actor arg2 ;
33883   Dali::Actor *argp2 ;
33884
33885   arg1 = (Dali::Actor *)jarg1;
33886   argp2 = (Dali::Actor *)jarg2;
33887   if (!argp2) {
33888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33889     return ;
33890   }
33891   arg2 = *argp2;
33892   {
33893     try {
33894       (arg1)->Add(arg2);
33895     } catch (std::out_of_range& e) {
33896       {
33897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33898       };
33899     } catch (std::exception& e) {
33900       {
33901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33902       };
33903     } catch (Dali::DaliException e) {
33904       {
33905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33906       };
33907     } catch (...) {
33908       {
33909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33910       };
33911     }
33912   }
33913
33914 }
33915
33916
33917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33919   Dali::Actor arg2 ;
33920   Dali::Actor *argp2 ;
33921
33922   arg1 = (Dali::Actor *)jarg1;
33923   argp2 = (Dali::Actor *)jarg2;
33924   if (!argp2) {
33925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33926     return ;
33927   }
33928   arg2 = *argp2;
33929   {
33930     try {
33931       (arg1)->Remove(arg2);
33932     } catch (std::out_of_range& e) {
33933       {
33934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33935       };
33936     } catch (std::exception& e) {
33937       {
33938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33939       };
33940     } catch (Dali::DaliException e) {
33941       {
33942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33943       };
33944     } catch (...) {
33945       {
33946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33947       };
33948     }
33949   }
33950
33951 }
33952
33953
33954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33955   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33956
33957   arg1 = (Dali::Actor *)jarg1;
33958   {
33959     try {
33960       (arg1)->Unparent();
33961     } catch (std::out_of_range& e) {
33962       {
33963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33964       };
33965     } catch (std::exception& e) {
33966       {
33967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33968       };
33969     } catch (Dali::DaliException e) {
33970       {
33971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33972       };
33973     } catch (...) {
33974       {
33975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33976       };
33977     }
33978   }
33979
33980 }
33981
33982
33983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33984   unsigned int jresult ;
33985   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33986   unsigned int result;
33987
33988   arg1 = (Dali::Actor *)jarg1;
33989   {
33990     try {
33991       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33992     } catch (std::out_of_range& e) {
33993       {
33994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33995       };
33996     } catch (std::exception& e) {
33997       {
33998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33999       };
34000     } catch (Dali::DaliException e) {
34001       {
34002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34003       };
34004     } catch (...) {
34005       {
34006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34007       };
34008     }
34009   }
34010
34011   jresult = result;
34012   return jresult;
34013 }
34014
34015
34016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34017   void * jresult ;
34018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34019   unsigned int arg2 ;
34020   Dali::Actor result;
34021
34022   arg1 = (Dali::Actor *)jarg1;
34023   arg2 = (unsigned int)jarg2;
34024   {
34025     try {
34026       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34027     } catch (std::out_of_range& e) {
34028       {
34029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34030       };
34031     } catch (std::exception& e) {
34032       {
34033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34034       };
34035     } catch (Dali::DaliException e) {
34036       {
34037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34038       };
34039     } catch (...) {
34040       {
34041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34042       };
34043     }
34044   }
34045
34046   jresult = new Dali::Actor((const Dali::Actor &)result);
34047   return jresult;
34048 }
34049
34050
34051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34052   void * jresult ;
34053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34054   std::string *arg2 = 0 ;
34055   Dali::Actor result;
34056
34057   arg1 = (Dali::Actor *)jarg1;
34058   if (!jarg2) {
34059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34060     return 0;
34061   }
34062   std::string arg2_str(jarg2);
34063   arg2 = &arg2_str;
34064   {
34065     try {
34066       result = (arg1)->FindChildByName((std::string const &)*arg2);
34067     } catch (std::out_of_range& e) {
34068       {
34069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34070       };
34071     } catch (std::exception& e) {
34072       {
34073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34074       };
34075     } catch (Dali::DaliException e) {
34076       {
34077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34078       };
34079     } catch (...) {
34080       {
34081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34082       };
34083     }
34084   }
34085
34086   jresult = new Dali::Actor((const Dali::Actor &)result);
34087
34088   //argout typemap for const std::string&
34089
34090   return jresult;
34091 }
34092
34093
34094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34095   void * jresult ;
34096   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34097   unsigned int arg2 ;
34098   Dali::Actor result;
34099
34100   arg1 = (Dali::Actor *)jarg1;
34101   arg2 = (unsigned int)jarg2;
34102   {
34103     try {
34104       result = (arg1)->FindChildById(arg2);
34105     } catch (std::out_of_range& e) {
34106       {
34107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34108       };
34109     } catch (std::exception& e) {
34110       {
34111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34112       };
34113     } catch (Dali::DaliException e) {
34114       {
34115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34116       };
34117     } catch (...) {
34118       {
34119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34120       };
34121     }
34122   }
34123
34124   jresult = new Dali::Actor((const Dali::Actor &)result);
34125   return jresult;
34126 }
34127
34128
34129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34130   void * jresult ;
34131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34132   Dali::Actor result;
34133
34134   arg1 = (Dali::Actor *)jarg1;
34135   {
34136     try {
34137       result = ((Dali::Actor const *)arg1)->GetParent();
34138     } catch (std::out_of_range& e) {
34139       {
34140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34141       };
34142     } catch (std::exception& e) {
34143       {
34144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34145       };
34146     } catch (Dali::DaliException e) {
34147       {
34148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34149       };
34150     } catch (...) {
34151       {
34152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34153       };
34154     }
34155   }
34156
34157   jresult = new Dali::Actor((const Dali::Actor &)result);
34158   return jresult;
34159 }
34160
34161
34162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34163   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34164   Dali::Vector3 *arg2 = 0 ;
34165
34166   arg1 = (Dali::Actor *)jarg1;
34167   arg2 = (Dali::Vector3 *)jarg2;
34168   if (!arg2) {
34169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34170     return ;
34171   }
34172   {
34173     try {
34174       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34175     } catch (std::out_of_range& e) {
34176       {
34177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34178       };
34179     } catch (std::exception& e) {
34180       {
34181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34182       };
34183     } catch (Dali::DaliException e) {
34184       {
34185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34186       };
34187     } catch (...) {
34188       {
34189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34190       };
34191     }
34192   }
34193
34194 }
34195
34196
34197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34198   void * jresult ;
34199   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34200   Dali::Vector3 result;
34201
34202   arg1 = (Dali::Actor *)jarg1;
34203   {
34204     try {
34205       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34206     } catch (std::out_of_range& e) {
34207       {
34208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34209       };
34210     } catch (std::exception& e) {
34211       {
34212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34213       };
34214     } catch (Dali::DaliException e) {
34215       {
34216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34217       };
34218     } catch (...) {
34219       {
34220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34221       };
34222     }
34223   }
34224
34225   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34226   return jresult;
34227 }
34228
34229
34230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34231   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34232   Dali::Vector3 *arg2 = 0 ;
34233
34234   arg1 = (Dali::Actor *)jarg1;
34235   arg2 = (Dali::Vector3 *)jarg2;
34236   if (!arg2) {
34237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34238     return ;
34239   }
34240   {
34241     try {
34242       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34243     } catch (std::out_of_range& e) {
34244       {
34245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34246       };
34247     } catch (std::exception& e) {
34248       {
34249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34250       };
34251     } catch (Dali::DaliException e) {
34252       {
34253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34254       };
34255     } catch (...) {
34256       {
34257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34258       };
34259     }
34260   }
34261
34262 }
34263
34264
34265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34266   void * jresult ;
34267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34268   Dali::Vector3 result;
34269
34270   arg1 = (Dali::Actor *)jarg1;
34271   {
34272     try {
34273       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34274     } catch (std::out_of_range& e) {
34275       {
34276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34277       };
34278     } catch (std::exception& e) {
34279       {
34280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34281       };
34282     } catch (Dali::DaliException e) {
34283       {
34284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34285       };
34286     } catch (...) {
34287       {
34288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34289       };
34290     }
34291   }
34292
34293   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34294   return jresult;
34295 }
34296
34297
34298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34299   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34300   float arg2 ;
34301   float arg3 ;
34302
34303   arg1 = (Dali::Actor *)jarg1;
34304   arg2 = (float)jarg2;
34305   arg3 = (float)jarg3;
34306   {
34307     try {
34308       (arg1)->SetSize(arg2,arg3);
34309     } catch (std::out_of_range& e) {
34310       {
34311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34312       };
34313     } catch (std::exception& e) {
34314       {
34315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34316       };
34317     } catch (Dali::DaliException e) {
34318       {
34319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34320       };
34321     } catch (...) {
34322       {
34323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34324       };
34325     }
34326   }
34327
34328 }
34329
34330
34331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34332   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34333   float arg2 ;
34334   float arg3 ;
34335   float arg4 ;
34336
34337   arg1 = (Dali::Actor *)jarg1;
34338   arg2 = (float)jarg2;
34339   arg3 = (float)jarg3;
34340   arg4 = (float)jarg4;
34341   {
34342     try {
34343       (arg1)->SetSize(arg2,arg3,arg4);
34344     } catch (std::out_of_range& e) {
34345       {
34346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34347       };
34348     } catch (std::exception& e) {
34349       {
34350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34351       };
34352     } catch (Dali::DaliException e) {
34353       {
34354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34355       };
34356     } catch (...) {
34357       {
34358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34359       };
34360     }
34361   }
34362
34363 }
34364
34365
34366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34367   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34368   Dali::Vector2 *arg2 = 0 ;
34369
34370   arg1 = (Dali::Actor *)jarg1;
34371   arg2 = (Dali::Vector2 *)jarg2;
34372   if (!arg2) {
34373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34374     return ;
34375   }
34376   {
34377     try {
34378       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34379     } catch (std::out_of_range& e) {
34380       {
34381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34382       };
34383     } catch (std::exception& e) {
34384       {
34385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34386       };
34387     } catch (Dali::DaliException e) {
34388       {
34389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34390       };
34391     } catch (...) {
34392       {
34393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34394       };
34395     }
34396   }
34397
34398 }
34399
34400
34401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34402   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34403   Dali::Vector3 *arg2 = 0 ;
34404
34405   arg1 = (Dali::Actor *)jarg1;
34406   arg2 = (Dali::Vector3 *)jarg2;
34407   if (!arg2) {
34408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34409     return ;
34410   }
34411   {
34412     try {
34413       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34414     } catch (std::out_of_range& e) {
34415       {
34416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34417       };
34418     } catch (std::exception& e) {
34419       {
34420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34421       };
34422     } catch (Dali::DaliException e) {
34423       {
34424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34425       };
34426     } catch (...) {
34427       {
34428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34429       };
34430     }
34431   }
34432
34433 }
34434
34435
34436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34437   void * jresult ;
34438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34439   Dali::Vector3 result;
34440
34441   arg1 = (Dali::Actor *)jarg1;
34442   {
34443     try {
34444       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34445     } catch (std::out_of_range& e) {
34446       {
34447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34448       };
34449     } catch (std::exception& e) {
34450       {
34451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34452       };
34453     } catch (Dali::DaliException e) {
34454       {
34455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34456       };
34457     } catch (...) {
34458       {
34459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34460       };
34461     }
34462   }
34463
34464   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34465   return jresult;
34466 }
34467
34468
34469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34470   void * jresult ;
34471   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34472   Dali::Vector3 result;
34473
34474   arg1 = (Dali::Actor *)jarg1;
34475   {
34476     try {
34477       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34478     } catch (std::out_of_range& e) {
34479       {
34480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34481       };
34482     } catch (std::exception& e) {
34483       {
34484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34485       };
34486     } catch (Dali::DaliException e) {
34487       {
34488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34489       };
34490     } catch (...) {
34491       {
34492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34493       };
34494     }
34495   }
34496
34497   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34498   return jresult;
34499 }
34500
34501
34502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34503   void * jresult ;
34504   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34505   Dali::Vector3 result;
34506
34507   arg1 = (Dali::Actor *)jarg1;
34508   {
34509     try {
34510       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34511     } catch (std::out_of_range& e) {
34512       {
34513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34514       };
34515     } catch (std::exception& e) {
34516       {
34517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34518       };
34519     } catch (Dali::DaliException e) {
34520       {
34521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34522       };
34523     } catch (...) {
34524       {
34525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34526       };
34527     }
34528   }
34529
34530   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34531   return jresult;
34532 }
34533
34534
34535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34537   float arg2 ;
34538   float arg3 ;
34539
34540   arg1 = (Dali::Actor *)jarg1;
34541   arg2 = (float)jarg2;
34542   arg3 = (float)jarg3;
34543   {
34544     try {
34545       (arg1)->SetPosition(arg2,arg3);
34546     } catch (std::out_of_range& e) {
34547       {
34548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34549       };
34550     } catch (std::exception& e) {
34551       {
34552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34553       };
34554     } catch (Dali::DaliException e) {
34555       {
34556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34557       };
34558     } catch (...) {
34559       {
34560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34561       };
34562     }
34563   }
34564
34565 }
34566
34567
34568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34569   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34570   float arg2 ;
34571   float arg3 ;
34572   float arg4 ;
34573
34574   arg1 = (Dali::Actor *)jarg1;
34575   arg2 = (float)jarg2;
34576   arg3 = (float)jarg3;
34577   arg4 = (float)jarg4;
34578   {
34579     try {
34580       (arg1)->SetPosition(arg2,arg3,arg4);
34581     } catch (std::out_of_range& e) {
34582       {
34583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34584       };
34585     } catch (std::exception& e) {
34586       {
34587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34588       };
34589     } catch (Dali::DaliException e) {
34590       {
34591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34592       };
34593     } catch (...) {
34594       {
34595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34596       };
34597     }
34598   }
34599
34600 }
34601
34602
34603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34605   Dali::Vector3 *arg2 = 0 ;
34606
34607   arg1 = (Dali::Actor *)jarg1;
34608   arg2 = (Dali::Vector3 *)jarg2;
34609   if (!arg2) {
34610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34611     return ;
34612   }
34613   {
34614     try {
34615       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34616     } catch (std::out_of_range& e) {
34617       {
34618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34619       };
34620     } catch (std::exception& e) {
34621       {
34622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34623       };
34624     } catch (Dali::DaliException e) {
34625       {
34626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34627       };
34628     } catch (...) {
34629       {
34630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34631       };
34632     }
34633   }
34634
34635 }
34636
34637
34638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34640   float arg2 ;
34641
34642   arg1 = (Dali::Actor *)jarg1;
34643   arg2 = (float)jarg2;
34644   {
34645     try {
34646       (arg1)->SetX(arg2);
34647     } catch (std::out_of_range& e) {
34648       {
34649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34650       };
34651     } catch (std::exception& e) {
34652       {
34653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34654       };
34655     } catch (Dali::DaliException e) {
34656       {
34657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34658       };
34659     } catch (...) {
34660       {
34661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34662       };
34663     }
34664   }
34665
34666 }
34667
34668
34669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34671   float arg2 ;
34672
34673   arg1 = (Dali::Actor *)jarg1;
34674   arg2 = (float)jarg2;
34675   {
34676     try {
34677       (arg1)->SetY(arg2);
34678     } catch (std::out_of_range& e) {
34679       {
34680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34681       };
34682     } catch (std::exception& e) {
34683       {
34684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34685       };
34686     } catch (Dali::DaliException e) {
34687       {
34688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34689       };
34690     } catch (...) {
34691       {
34692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34693       };
34694     }
34695   }
34696
34697 }
34698
34699
34700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34702   float arg2 ;
34703
34704   arg1 = (Dali::Actor *)jarg1;
34705   arg2 = (float)jarg2;
34706   {
34707     try {
34708       (arg1)->SetZ(arg2);
34709     } catch (std::out_of_range& e) {
34710       {
34711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34712       };
34713     } catch (std::exception& e) {
34714       {
34715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34716       };
34717     } catch (Dali::DaliException e) {
34718       {
34719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34720       };
34721     } catch (...) {
34722       {
34723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34724       };
34725     }
34726   }
34727
34728 }
34729
34730
34731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34732   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34733   Dali::Vector3 *arg2 = 0 ;
34734
34735   arg1 = (Dali::Actor *)jarg1;
34736   arg2 = (Dali::Vector3 *)jarg2;
34737   if (!arg2) {
34738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34739     return ;
34740   }
34741   {
34742     try {
34743       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34744     } catch (std::out_of_range& e) {
34745       {
34746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34747       };
34748     } catch (std::exception& e) {
34749       {
34750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34751       };
34752     } catch (Dali::DaliException e) {
34753       {
34754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34755       };
34756     } catch (...) {
34757       {
34758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34759       };
34760     }
34761   }
34762
34763 }
34764
34765
34766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34767   void * jresult ;
34768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34769   Dali::Vector3 result;
34770
34771   arg1 = (Dali::Actor *)jarg1;
34772   {
34773     try {
34774       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34775     } catch (std::out_of_range& e) {
34776       {
34777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34778       };
34779     } catch (std::exception& e) {
34780       {
34781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34782       };
34783     } catch (Dali::DaliException e) {
34784       {
34785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34786       };
34787     } catch (...) {
34788       {
34789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34790       };
34791     }
34792   }
34793
34794   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34795   return jresult;
34796 }
34797
34798
34799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34800   void * jresult ;
34801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34802   Dali::Vector3 result;
34803
34804   arg1 = (Dali::Actor *)jarg1;
34805   {
34806     try {
34807       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34808     } catch (std::out_of_range& e) {
34809       {
34810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34811       };
34812     } catch (std::exception& e) {
34813       {
34814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34815       };
34816     } catch (Dali::DaliException e) {
34817       {
34818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34819       };
34820     } catch (...) {
34821       {
34822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34823       };
34824     }
34825   }
34826
34827   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34828   return jresult;
34829 }
34830
34831
34832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34834   bool arg2 ;
34835
34836   arg1 = (Dali::Actor *)jarg1;
34837   arg2 = jarg2 ? true : false;
34838   {
34839     try {
34840       (arg1)->SetInheritPosition(arg2);
34841     } catch (std::out_of_range& e) {
34842       {
34843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34844       };
34845     } catch (std::exception& e) {
34846       {
34847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34848       };
34849     } catch (Dali::DaliException e) {
34850       {
34851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34852       };
34853     } catch (...) {
34854       {
34855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34856       };
34857     }
34858   }
34859
34860 }
34861
34862
34863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34864   int jresult ;
34865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34866   Dali::PositionInheritanceMode result;
34867
34868   arg1 = (Dali::Actor *)jarg1;
34869   {
34870     try {
34871       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34872     } catch (std::out_of_range& e) {
34873       {
34874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34875       };
34876     } catch (std::exception& e) {
34877       {
34878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34879       };
34880     } catch (Dali::DaliException e) {
34881       {
34882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34883       };
34884     } catch (...) {
34885       {
34886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34887       };
34888     }
34889   }
34890
34891   jresult = (int)result;
34892   return jresult;
34893 }
34894
34895
34896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34897   unsigned int jresult ;
34898   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34899   bool result;
34900
34901   arg1 = (Dali::Actor *)jarg1;
34902   {
34903     try {
34904       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34905     } catch (std::out_of_range& e) {
34906       {
34907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34908       };
34909     } catch (std::exception& e) {
34910       {
34911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34912       };
34913     } catch (Dali::DaliException e) {
34914       {
34915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34916       };
34917     } catch (...) {
34918       {
34919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34920       };
34921     }
34922   }
34923
34924   jresult = result;
34925   return jresult;
34926 }
34927
34928
34929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34931   Dali::Degree *arg2 = 0 ;
34932   Dali::Vector3 *arg3 = 0 ;
34933
34934   arg1 = (Dali::Actor *)jarg1;
34935   arg2 = (Dali::Degree *)jarg2;
34936   if (!arg2) {
34937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34938     return ;
34939   }
34940   arg3 = (Dali::Vector3 *)jarg3;
34941   if (!arg3) {
34942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34943     return ;
34944   }
34945   {
34946     try {
34947       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34948     } catch (std::out_of_range& e) {
34949       {
34950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34951       };
34952     } catch (std::exception& e) {
34953       {
34954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34955       };
34956     } catch (Dali::DaliException e) {
34957       {
34958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34959       };
34960     } catch (...) {
34961       {
34962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34963       };
34964     }
34965   }
34966
34967 }
34968
34969
34970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34972   Dali::Radian *arg2 = 0 ;
34973   Dali::Vector3 *arg3 = 0 ;
34974
34975   arg1 = (Dali::Actor *)jarg1;
34976   arg2 = (Dali::Radian *)jarg2;
34977   if (!arg2) {
34978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34979     return ;
34980   }
34981   arg3 = (Dali::Vector3 *)jarg3;
34982   if (!arg3) {
34983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34984     return ;
34985   }
34986   {
34987     try {
34988       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34989     } catch (std::out_of_range& e) {
34990       {
34991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34992       };
34993     } catch (std::exception& e) {
34994       {
34995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34996       };
34997     } catch (Dali::DaliException e) {
34998       {
34999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35000       };
35001     } catch (...) {
35002       {
35003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35004       };
35005     }
35006   }
35007
35008 }
35009
35010
35011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35013   Dali::Quaternion *arg2 = 0 ;
35014
35015   arg1 = (Dali::Actor *)jarg1;
35016   arg2 = (Dali::Quaternion *)jarg2;
35017   if (!arg2) {
35018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35019     return ;
35020   }
35021   {
35022     try {
35023       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35024     } catch (std::out_of_range& e) {
35025       {
35026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35027       };
35028     } catch (std::exception& e) {
35029       {
35030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35031       };
35032     } catch (Dali::DaliException e) {
35033       {
35034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35035       };
35036     } catch (...) {
35037       {
35038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35039       };
35040     }
35041   }
35042
35043 }
35044
35045
35046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35048   Dali::Degree *arg2 = 0 ;
35049   Dali::Vector3 *arg3 = 0 ;
35050
35051   arg1 = (Dali::Actor *)jarg1;
35052   arg2 = (Dali::Degree *)jarg2;
35053   if (!arg2) {
35054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35055     return ;
35056   }
35057   arg3 = (Dali::Vector3 *)jarg3;
35058   if (!arg3) {
35059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35060     return ;
35061   }
35062   {
35063     try {
35064       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35065     } catch (std::out_of_range& e) {
35066       {
35067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35068       };
35069     } catch (std::exception& e) {
35070       {
35071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35072       };
35073     } catch (Dali::DaliException e) {
35074       {
35075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35076       };
35077     } catch (...) {
35078       {
35079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35080       };
35081     }
35082   }
35083
35084 }
35085
35086
35087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35089   Dali::Radian *arg2 = 0 ;
35090   Dali::Vector3 *arg3 = 0 ;
35091
35092   arg1 = (Dali::Actor *)jarg1;
35093   arg2 = (Dali::Radian *)jarg2;
35094   if (!arg2) {
35095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35096     return ;
35097   }
35098   arg3 = (Dali::Vector3 *)jarg3;
35099   if (!arg3) {
35100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35101     return ;
35102   }
35103   {
35104     try {
35105       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35106     } catch (std::out_of_range& e) {
35107       {
35108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35109       };
35110     } catch (std::exception& e) {
35111       {
35112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35113       };
35114     } catch (Dali::DaliException e) {
35115       {
35116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35117       };
35118     } catch (...) {
35119       {
35120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35121       };
35122     }
35123   }
35124
35125 }
35126
35127
35128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35129   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35130   Dali::Quaternion *arg2 = 0 ;
35131
35132   arg1 = (Dali::Actor *)jarg1;
35133   arg2 = (Dali::Quaternion *)jarg2;
35134   if (!arg2) {
35135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35136     return ;
35137   }
35138   {
35139     try {
35140       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35141     } catch (std::out_of_range& e) {
35142       {
35143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35144       };
35145     } catch (std::exception& e) {
35146       {
35147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35148       };
35149     } catch (Dali::DaliException e) {
35150       {
35151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35152       };
35153     } catch (...) {
35154       {
35155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35156       };
35157     }
35158   }
35159
35160 }
35161
35162
35163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35164   void * jresult ;
35165   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35166   Dali::Quaternion result;
35167
35168   arg1 = (Dali::Actor *)jarg1;
35169   {
35170     try {
35171       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35172     } catch (std::out_of_range& e) {
35173       {
35174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35175       };
35176     } catch (std::exception& e) {
35177       {
35178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35179       };
35180     } catch (Dali::DaliException e) {
35181       {
35182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35183       };
35184     } catch (...) {
35185       {
35186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35187       };
35188     }
35189   }
35190
35191   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35192   return jresult;
35193 }
35194
35195
35196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35197   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35198   bool arg2 ;
35199
35200   arg1 = (Dali::Actor *)jarg1;
35201   arg2 = jarg2 ? true : false;
35202   {
35203     try {
35204       (arg1)->SetInheritOrientation(arg2);
35205     } catch (std::out_of_range& e) {
35206       {
35207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35208       };
35209     } catch (std::exception& e) {
35210       {
35211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35212       };
35213     } catch (Dali::DaliException e) {
35214       {
35215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35216       };
35217     } catch (...) {
35218       {
35219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35220       };
35221     }
35222   }
35223
35224 }
35225
35226
35227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35228   unsigned int jresult ;
35229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35230   bool result;
35231
35232   arg1 = (Dali::Actor *)jarg1;
35233   {
35234     try {
35235       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35236     } catch (std::out_of_range& e) {
35237       {
35238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35239       };
35240     } catch (std::exception& e) {
35241       {
35242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35243       };
35244     } catch (Dali::DaliException e) {
35245       {
35246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35247       };
35248     } catch (...) {
35249       {
35250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35251       };
35252     }
35253   }
35254
35255   jresult = result;
35256   return jresult;
35257 }
35258
35259
35260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35261   void * jresult ;
35262   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35263   Dali::Quaternion result;
35264
35265   arg1 = (Dali::Actor *)jarg1;
35266   {
35267     try {
35268       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35269     } catch (std::out_of_range& e) {
35270       {
35271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35272       };
35273     } catch (std::exception& e) {
35274       {
35275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35276       };
35277     } catch (Dali::DaliException e) {
35278       {
35279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35280       };
35281     } catch (...) {
35282       {
35283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35284       };
35285     }
35286   }
35287
35288   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35289   return jresult;
35290 }
35291
35292
35293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35295   float arg2 ;
35296
35297   arg1 = (Dali::Actor *)jarg1;
35298   arg2 = (float)jarg2;
35299   {
35300     try {
35301       (arg1)->SetScale(arg2);
35302     } catch (std::out_of_range& e) {
35303       {
35304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35305       };
35306     } catch (std::exception& e) {
35307       {
35308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35309       };
35310     } catch (Dali::DaliException e) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35313       };
35314     } catch (...) {
35315       {
35316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35317       };
35318     }
35319   }
35320
35321 }
35322
35323
35324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35326   float arg2 ;
35327   float arg3 ;
35328   float arg4 ;
35329
35330   arg1 = (Dali::Actor *)jarg1;
35331   arg2 = (float)jarg2;
35332   arg3 = (float)jarg3;
35333   arg4 = (float)jarg4;
35334   {
35335     try {
35336       (arg1)->SetScale(arg2,arg3,arg4);
35337     } catch (std::out_of_range& e) {
35338       {
35339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (std::exception& e) {
35342       {
35343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35344       };
35345     } catch (Dali::DaliException e) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35348       };
35349     } catch (...) {
35350       {
35351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35352       };
35353     }
35354   }
35355
35356 }
35357
35358
35359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35361   Dali::Vector3 *arg2 = 0 ;
35362
35363   arg1 = (Dali::Actor *)jarg1;
35364   arg2 = (Dali::Vector3 *)jarg2;
35365   if (!arg2) {
35366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35367     return ;
35368   }
35369   {
35370     try {
35371       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35372     } catch (std::out_of_range& e) {
35373       {
35374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35375       };
35376     } catch (std::exception& e) {
35377       {
35378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35379       };
35380     } catch (Dali::DaliException e) {
35381       {
35382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35383       };
35384     } catch (...) {
35385       {
35386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35387       };
35388     }
35389   }
35390
35391 }
35392
35393
35394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35396   Dali::Vector3 *arg2 = 0 ;
35397
35398   arg1 = (Dali::Actor *)jarg1;
35399   arg2 = (Dali::Vector3 *)jarg2;
35400   if (!arg2) {
35401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35402     return ;
35403   }
35404   {
35405     try {
35406       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35407     } catch (std::out_of_range& e) {
35408       {
35409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35410       };
35411     } catch (std::exception& e) {
35412       {
35413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35414       };
35415     } catch (Dali::DaliException e) {
35416       {
35417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35418       };
35419     } catch (...) {
35420       {
35421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35422       };
35423     }
35424   }
35425
35426 }
35427
35428
35429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35430   void * jresult ;
35431   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35432   Dali::Vector3 result;
35433
35434   arg1 = (Dali::Actor *)jarg1;
35435   {
35436     try {
35437       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35438     } catch (std::out_of_range& e) {
35439       {
35440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35441       };
35442     } catch (std::exception& e) {
35443       {
35444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35445       };
35446     } catch (Dali::DaliException e) {
35447       {
35448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35449       };
35450     } catch (...) {
35451       {
35452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35453       };
35454     }
35455   }
35456
35457   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35458   return jresult;
35459 }
35460
35461
35462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35463   void * jresult ;
35464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35465   Dali::Vector3 result;
35466
35467   arg1 = (Dali::Actor *)jarg1;
35468   {
35469     try {
35470       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35471     } catch (std::out_of_range& e) {
35472       {
35473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35474       };
35475     } catch (std::exception& e) {
35476       {
35477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35478       };
35479     } catch (Dali::DaliException e) {
35480       {
35481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35482       };
35483     } catch (...) {
35484       {
35485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35486       };
35487     }
35488   }
35489
35490   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35491   return jresult;
35492 }
35493
35494
35495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35497   bool arg2 ;
35498
35499   arg1 = (Dali::Actor *)jarg1;
35500   arg2 = jarg2 ? true : false;
35501   {
35502     try {
35503       (arg1)->SetInheritScale(arg2);
35504     } catch (std::out_of_range& e) {
35505       {
35506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35507       };
35508     } catch (std::exception& e) {
35509       {
35510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35511       };
35512     } catch (Dali::DaliException e) {
35513       {
35514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35515       };
35516     } catch (...) {
35517       {
35518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35519       };
35520     }
35521   }
35522
35523 }
35524
35525
35526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35527   unsigned int jresult ;
35528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35529   bool result;
35530
35531   arg1 = (Dali::Actor *)jarg1;
35532   {
35533     try {
35534       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35535     } catch (std::out_of_range& e) {
35536       {
35537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35538       };
35539     } catch (std::exception& e) {
35540       {
35541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35542       };
35543     } catch (Dali::DaliException e) {
35544       {
35545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35546       };
35547     } catch (...) {
35548       {
35549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35550       };
35551     }
35552   }
35553
35554   jresult = result;
35555   return jresult;
35556 }
35557
35558
35559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35560   void * jresult ;
35561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35562   Dali::Matrix result;
35563
35564   arg1 = (Dali::Actor *)jarg1;
35565   {
35566     try {
35567       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35568     } catch (std::out_of_range& e) {
35569       {
35570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35571       };
35572     } catch (std::exception& e) {
35573       {
35574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35575       };
35576     } catch (Dali::DaliException e) {
35577       {
35578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35579       };
35580     } catch (...) {
35581       {
35582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35583       };
35584     }
35585   }
35586
35587   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35588   return jresult;
35589 }
35590
35591
35592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35594   bool arg2 ;
35595
35596   arg1 = (Dali::Actor *)jarg1;
35597   arg2 = jarg2 ? true : false;
35598   {
35599     try {
35600       (arg1)->SetVisible(arg2);
35601     } catch (std::out_of_range& e) {
35602       {
35603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35604       };
35605     } catch (std::exception& e) {
35606       {
35607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35608       };
35609     } catch (Dali::DaliException e) {
35610       {
35611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35612       };
35613     } catch (...) {
35614       {
35615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35616       };
35617     }
35618   }
35619
35620 }
35621
35622
35623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35624   unsigned int jresult ;
35625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35626   bool result;
35627
35628   arg1 = (Dali::Actor *)jarg1;
35629   {
35630     try {
35631       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35632     } catch (std::out_of_range& e) {
35633       {
35634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35635       };
35636     } catch (std::exception& e) {
35637       {
35638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35639       };
35640     } catch (Dali::DaliException e) {
35641       {
35642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35643       };
35644     } catch (...) {
35645       {
35646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35647       };
35648     }
35649   }
35650
35651   jresult = result;
35652   return jresult;
35653 }
35654
35655
35656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35657   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35658   float arg2 ;
35659
35660   arg1 = (Dali::Actor *)jarg1;
35661   arg2 = (float)jarg2;
35662   {
35663     try {
35664       (arg1)->SetOpacity(arg2);
35665     } catch (std::out_of_range& e) {
35666       {
35667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35668       };
35669     } catch (std::exception& e) {
35670       {
35671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35672       };
35673     } catch (Dali::DaliException e) {
35674       {
35675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35676       };
35677     } catch (...) {
35678       {
35679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35680       };
35681     }
35682   }
35683
35684 }
35685
35686
35687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35688   float jresult ;
35689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35690   float result;
35691
35692   arg1 = (Dali::Actor *)jarg1;
35693   {
35694     try {
35695       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35696     } catch (std::out_of_range& e) {
35697       {
35698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35699       };
35700     } catch (std::exception& e) {
35701       {
35702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35703       };
35704     } catch (Dali::DaliException e) {
35705       {
35706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35707       };
35708     } catch (...) {
35709       {
35710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35711       };
35712     }
35713   }
35714
35715   jresult = result;
35716   return jresult;
35717 }
35718
35719
35720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35721   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35722   Dali::Vector4 *arg2 = 0 ;
35723
35724   arg1 = (Dali::Actor *)jarg1;
35725   arg2 = (Dali::Vector4 *)jarg2;
35726   if (!arg2) {
35727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35728     return ;
35729   }
35730   {
35731     try {
35732       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35733     } catch (std::out_of_range& e) {
35734       {
35735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35736       };
35737     } catch (std::exception& e) {
35738       {
35739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35740       };
35741     } catch (Dali::DaliException e) {
35742       {
35743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35744       };
35745     } catch (...) {
35746       {
35747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35748       };
35749     }
35750   }
35751
35752 }
35753
35754
35755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35756   void * jresult ;
35757   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35758   Dali::Vector4 result;
35759
35760   arg1 = (Dali::Actor *)jarg1;
35761   {
35762     try {
35763       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35764     } catch (std::out_of_range& e) {
35765       {
35766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35767       };
35768     } catch (std::exception& e) {
35769       {
35770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35771       };
35772     } catch (Dali::DaliException e) {
35773       {
35774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35775       };
35776     } catch (...) {
35777       {
35778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35779       };
35780     }
35781   }
35782
35783   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35784   return jresult;
35785 }
35786
35787
35788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35789   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35790   Dali::ColorMode arg2 ;
35791
35792   arg1 = (Dali::Actor *)jarg1;
35793   arg2 = (Dali::ColorMode)jarg2;
35794   {
35795     try {
35796       (arg1)->SetColorMode(arg2);
35797     } catch (std::out_of_range& e) {
35798       {
35799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35800       };
35801     } catch (std::exception& e) {
35802       {
35803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35804       };
35805     } catch (Dali::DaliException e) {
35806       {
35807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35808       };
35809     } catch (...) {
35810       {
35811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35812       };
35813     }
35814   }
35815
35816 }
35817
35818
35819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35820   int jresult ;
35821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35822   Dali::ColorMode result;
35823
35824   arg1 = (Dali::Actor *)jarg1;
35825   {
35826     try {
35827       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35828     } catch (std::out_of_range& e) {
35829       {
35830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35831       };
35832     } catch (std::exception& e) {
35833       {
35834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35835       };
35836     } catch (Dali::DaliException e) {
35837       {
35838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35839       };
35840     } catch (...) {
35841       {
35842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35843       };
35844     }
35845   }
35846
35847   jresult = (int)result;
35848   return jresult;
35849 }
35850
35851
35852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35853   void * jresult ;
35854   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35855   Dali::Vector4 result;
35856
35857   arg1 = (Dali::Actor *)jarg1;
35858   {
35859     try {
35860       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35861     } catch (std::out_of_range& e) {
35862       {
35863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35864       };
35865     } catch (std::exception& e) {
35866       {
35867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35868       };
35869     } catch (Dali::DaliException e) {
35870       {
35871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35872       };
35873     } catch (...) {
35874       {
35875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35876       };
35877     }
35878   }
35879
35880   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35881   return jresult;
35882 }
35883
35884
35885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35887   Dali::DrawMode::Type arg2 ;
35888
35889   arg1 = (Dali::Actor *)jarg1;
35890   arg2 = (Dali::DrawMode::Type)jarg2;
35891   {
35892     try {
35893       (arg1)->SetDrawMode(arg2);
35894     } catch (std::out_of_range& e) {
35895       {
35896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35897       };
35898     } catch (std::exception& e) {
35899       {
35900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35901       };
35902     } catch (Dali::DaliException e) {
35903       {
35904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35905       };
35906     } catch (...) {
35907       {
35908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35909       };
35910     }
35911   }
35912
35913 }
35914
35915
35916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35917   int jresult ;
35918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35919   Dali::DrawMode::Type result;
35920
35921   arg1 = (Dali::Actor *)jarg1;
35922   {
35923     try {
35924       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35925     } catch (std::out_of_range& e) {
35926       {
35927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35928       };
35929     } catch (std::exception& e) {
35930       {
35931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35932       };
35933     } catch (Dali::DaliException e) {
35934       {
35935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35936       };
35937     } catch (...) {
35938       {
35939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35940       };
35941     }
35942   }
35943
35944   jresult = (int)result;
35945   return jresult;
35946 }
35947
35948
35949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35951   bool arg2 ;
35952
35953   arg1 = (Dali::Actor *)jarg1;
35954   arg2 = jarg2 ? true : false;
35955   {
35956     try {
35957       (arg1)->SetSensitive(arg2);
35958     } catch (std::out_of_range& e) {
35959       {
35960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35961       };
35962     } catch (std::exception& e) {
35963       {
35964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35965       };
35966     } catch (Dali::DaliException e) {
35967       {
35968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35969       };
35970     } catch (...) {
35971       {
35972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35973       };
35974     }
35975   }
35976
35977 }
35978
35979
35980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35981   unsigned int jresult ;
35982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35983   bool result;
35984
35985   arg1 = (Dali::Actor *)jarg1;
35986   {
35987     try {
35988       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35989     } catch (std::out_of_range& e) {
35990       {
35991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35992       };
35993     } catch (std::exception& e) {
35994       {
35995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35996       };
35997     } catch (Dali::DaliException e) {
35998       {
35999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36000       };
36001     } catch (...) {
36002       {
36003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36004       };
36005     }
36006   }
36007
36008   jresult = result;
36009   return jresult;
36010 }
36011
36012
36013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36014   unsigned int jresult ;
36015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36016   float *arg2 = 0 ;
36017   float *arg3 = 0 ;
36018   float arg4 ;
36019   float arg5 ;
36020   bool result;
36021
36022   arg1 = (Dali::Actor *)jarg1;
36023   arg2 = (float *)jarg2;
36024   arg3 = (float *)jarg3;
36025   arg4 = (float)jarg4;
36026   arg5 = (float)jarg5;
36027   {
36028     try {
36029       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36030     } catch (std::out_of_range& e) {
36031       {
36032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36033       };
36034     } catch (std::exception& e) {
36035       {
36036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36037       };
36038     } catch (Dali::DaliException e) {
36039       {
36040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36041       };
36042     } catch (...) {
36043       {
36044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36045       };
36046     }
36047   }
36048
36049   jresult = result;
36050   return jresult;
36051 }
36052
36053
36054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36055   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36056   bool arg2 ;
36057
36058   arg1 = (Dali::Actor *)jarg1;
36059   arg2 = jarg2 ? true : false;
36060   {
36061     try {
36062       (arg1)->SetLeaveRequired(arg2);
36063     } catch (std::out_of_range& e) {
36064       {
36065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36066       };
36067     } catch (std::exception& e) {
36068       {
36069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36070       };
36071     } catch (Dali::DaliException e) {
36072       {
36073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36074       };
36075     } catch (...) {
36076       {
36077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36078       };
36079     }
36080   }
36081
36082 }
36083
36084
36085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36086   unsigned int jresult ;
36087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36088   bool result;
36089
36090   arg1 = (Dali::Actor *)jarg1;
36091   {
36092     try {
36093       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36094     } catch (std::out_of_range& e) {
36095       {
36096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36097       };
36098     } catch (std::exception& e) {
36099       {
36100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36101       };
36102     } catch (Dali::DaliException e) {
36103       {
36104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36105       };
36106     } catch (...) {
36107       {
36108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36109       };
36110     }
36111   }
36112
36113   jresult = result;
36114   return jresult;
36115 }
36116
36117
36118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36119   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36120   bool arg2 ;
36121
36122   arg1 = (Dali::Actor *)jarg1;
36123   arg2 = jarg2 ? true : false;
36124   {
36125     try {
36126       (arg1)->SetKeyboardFocusable(arg2);
36127     } catch (std::out_of_range& e) {
36128       {
36129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36130       };
36131     } catch (std::exception& e) {
36132       {
36133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36134       };
36135     } catch (Dali::DaliException e) {
36136       {
36137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36138       };
36139     } catch (...) {
36140       {
36141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36142       };
36143     }
36144   }
36145
36146 }
36147
36148
36149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36150   unsigned int jresult ;
36151   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36152   bool result;
36153
36154   arg1 = (Dali::Actor *)jarg1;
36155   {
36156     try {
36157       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36158     } catch (std::out_of_range& e) {
36159       {
36160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36161       };
36162     } catch (std::exception& e) {
36163       {
36164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36165       };
36166     } catch (Dali::DaliException e) {
36167       {
36168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36169       };
36170     } catch (...) {
36171       {
36172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36173       };
36174     }
36175   }
36176
36177   jresult = result;
36178   return jresult;
36179 }
36180
36181
36182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36183   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36184   Dali::ResizePolicy::Type arg2 ;
36185   Dali::Dimension::Type arg3 ;
36186
36187   arg1 = (Dali::Actor *)jarg1;
36188   arg2 = (Dali::ResizePolicy::Type)jarg2;
36189   arg3 = (Dali::Dimension::Type)jarg3;
36190   {
36191     try {
36192       (arg1)->SetResizePolicy(arg2,arg3);
36193     } catch (std::out_of_range& e) {
36194       {
36195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36196       };
36197     } catch (std::exception& e) {
36198       {
36199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36200       };
36201     } catch (Dali::DaliException e) {
36202       {
36203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36204       };
36205     } catch (...) {
36206       {
36207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36208       };
36209     }
36210   }
36211
36212 }
36213
36214
36215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36216   int jresult ;
36217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36218   Dali::Dimension::Type arg2 ;
36219   Dali::ResizePolicy::Type result;
36220
36221   arg1 = (Dali::Actor *)jarg1;
36222   arg2 = (Dali::Dimension::Type)jarg2;
36223   {
36224     try {
36225       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36226     } catch (std::out_of_range& e) {
36227       {
36228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36229       };
36230     } catch (std::exception& e) {
36231       {
36232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36233       };
36234     } catch (Dali::DaliException e) {
36235       {
36236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36237       };
36238     } catch (...) {
36239       {
36240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36241       };
36242     }
36243   }
36244
36245   jresult = (int)result;
36246   return jresult;
36247 }
36248
36249
36250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36251   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36252   Dali::SizeScalePolicy::Type arg2 ;
36253
36254   arg1 = (Dali::Actor *)jarg1;
36255   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36256   {
36257     try {
36258       (arg1)->SetSizeScalePolicy(arg2);
36259     } catch (std::out_of_range& e) {
36260       {
36261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36262       };
36263     } catch (std::exception& e) {
36264       {
36265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36266       };
36267     } catch (Dali::DaliException e) {
36268       {
36269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36270       };
36271     } catch (...) {
36272       {
36273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36274       };
36275     }
36276   }
36277
36278 }
36279
36280
36281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36282   int jresult ;
36283   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36284   Dali::SizeScalePolicy::Type result;
36285
36286   arg1 = (Dali::Actor *)jarg1;
36287   {
36288     try {
36289       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36290     } catch (std::out_of_range& e) {
36291       {
36292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36293       };
36294     } catch (std::exception& e) {
36295       {
36296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36297       };
36298     } catch (Dali::DaliException e) {
36299       {
36300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36301       };
36302     } catch (...) {
36303       {
36304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36305       };
36306     }
36307   }
36308
36309   jresult = (int)result;
36310   return jresult;
36311 }
36312
36313
36314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36315   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36316   Dali::Vector3 *arg2 = 0 ;
36317
36318   arg1 = (Dali::Actor *)jarg1;
36319   arg2 = (Dali::Vector3 *)jarg2;
36320   if (!arg2) {
36321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36322     return ;
36323   }
36324   {
36325     try {
36326       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36327     } catch (std::out_of_range& e) {
36328       {
36329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36330       };
36331     } catch (std::exception& e) {
36332       {
36333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36334       };
36335     } catch (Dali::DaliException e) {
36336       {
36337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36338       };
36339     } catch (...) {
36340       {
36341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36342       };
36343     }
36344   }
36345
36346 }
36347
36348
36349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36350   void * jresult ;
36351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36352   Dali::Vector3 result;
36353
36354   arg1 = (Dali::Actor *)jarg1;
36355   {
36356     try {
36357       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36358     } catch (std::out_of_range& e) {
36359       {
36360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (std::exception& e) {
36363       {
36364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36365       };
36366     } catch (Dali::DaliException e) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36369       };
36370     } catch (...) {
36371       {
36372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36373       };
36374     }
36375   }
36376
36377   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36378   return jresult;
36379 }
36380
36381
36382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36383   float jresult ;
36384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36385   float arg2 ;
36386   float result;
36387
36388   arg1 = (Dali::Actor *)jarg1;
36389   arg2 = (float)jarg2;
36390   {
36391     try {
36392       result = (float)(arg1)->GetHeightForWidth(arg2);
36393     } catch (std::out_of_range& e) {
36394       {
36395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36396       };
36397     } catch (std::exception& e) {
36398       {
36399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36400       };
36401     } catch (Dali::DaliException e) {
36402       {
36403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36404       };
36405     } catch (...) {
36406       {
36407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36408       };
36409     }
36410   }
36411
36412   jresult = result;
36413   return jresult;
36414 }
36415
36416
36417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36418   float jresult ;
36419   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36420   float arg2 ;
36421   float result;
36422
36423   arg1 = (Dali::Actor *)jarg1;
36424   arg2 = (float)jarg2;
36425   {
36426     try {
36427       result = (float)(arg1)->GetWidthForHeight(arg2);
36428     } catch (std::out_of_range& e) {
36429       {
36430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36431       };
36432     } catch (std::exception& e) {
36433       {
36434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36435       };
36436     } catch (Dali::DaliException e) {
36437       {
36438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36439       };
36440     } catch (...) {
36441       {
36442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36443       };
36444     }
36445   }
36446
36447   jresult = result;
36448   return jresult;
36449 }
36450
36451
36452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36453   float jresult ;
36454   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36455   Dali::Dimension::Type arg2 ;
36456   float result;
36457
36458   arg1 = (Dali::Actor *)jarg1;
36459   arg2 = (Dali::Dimension::Type)jarg2;
36460   {
36461     try {
36462       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36463     } catch (std::out_of_range& e) {
36464       {
36465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36466       };
36467     } catch (std::exception& e) {
36468       {
36469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36470       };
36471     } catch (Dali::DaliException e) {
36472       {
36473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36474       };
36475     } catch (...) {
36476       {
36477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36478       };
36479     }
36480   }
36481
36482   jresult = result;
36483   return jresult;
36484 }
36485
36486
36487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36489   Dali::Padding *arg2 = 0 ;
36490
36491   arg1 = (Dali::Actor *)jarg1;
36492   arg2 = (Dali::Padding *)jarg2;
36493   if (!arg2) {
36494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36495     return ;
36496   }
36497   {
36498     try {
36499       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36500     } catch (std::out_of_range& e) {
36501       {
36502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36503       };
36504     } catch (std::exception& e) {
36505       {
36506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36507       };
36508     } catch (Dali::DaliException e) {
36509       {
36510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36511       };
36512     } catch (...) {
36513       {
36514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36515       };
36516     }
36517   }
36518
36519 }
36520
36521
36522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36524   Dali::Padding *arg2 = 0 ;
36525
36526   arg1 = (Dali::Actor *)jarg1;
36527   arg2 = (Dali::Padding *)jarg2;
36528   if (!arg2) {
36529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36530     return ;
36531   }
36532   {
36533     try {
36534       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36535     } catch (std::out_of_range& e) {
36536       {
36537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36538       };
36539     } catch (std::exception& e) {
36540       {
36541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36542       };
36543     } catch (Dali::DaliException e) {
36544       {
36545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36546       };
36547     } catch (...) {
36548       {
36549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36550       };
36551     }
36552   }
36553
36554 }
36555
36556
36557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36558   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36559   Dali::Vector2 *arg2 = 0 ;
36560
36561   arg1 = (Dali::Actor *)jarg1;
36562   arg2 = (Dali::Vector2 *)jarg2;
36563   if (!arg2) {
36564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36565     return ;
36566   }
36567   {
36568     try {
36569       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36570     } catch (std::out_of_range& e) {
36571       {
36572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36573       };
36574     } catch (std::exception& e) {
36575       {
36576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36577       };
36578     } catch (Dali::DaliException e) {
36579       {
36580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36581       };
36582     } catch (...) {
36583       {
36584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36585       };
36586     }
36587   }
36588
36589 }
36590
36591
36592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36593   void * jresult ;
36594   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36595   Dali::Vector2 result;
36596
36597   arg1 = (Dali::Actor *)jarg1;
36598   {
36599     try {
36600       result = (arg1)->GetMinimumSize();
36601     } catch (std::out_of_range& e) {
36602       {
36603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36604       };
36605     } catch (std::exception& e) {
36606       {
36607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36608       };
36609     } catch (Dali::DaliException e) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36612       };
36613     } catch (...) {
36614       {
36615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36616       };
36617     }
36618   }
36619
36620   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36621   return jresult;
36622 }
36623
36624
36625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36627   Dali::Vector2 *arg2 = 0 ;
36628
36629   arg1 = (Dali::Actor *)jarg1;
36630   arg2 = (Dali::Vector2 *)jarg2;
36631   if (!arg2) {
36632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36633     return ;
36634   }
36635   {
36636     try {
36637       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36638     } catch (std::out_of_range& e) {
36639       {
36640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36641       };
36642     } catch (std::exception& e) {
36643       {
36644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36645       };
36646     } catch (Dali::DaliException e) {
36647       {
36648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36649       };
36650     } catch (...) {
36651       {
36652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36653       };
36654     }
36655   }
36656
36657 }
36658
36659
36660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36661   void * jresult ;
36662   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36663   Dali::Vector2 result;
36664
36665   arg1 = (Dali::Actor *)jarg1;
36666   {
36667     try {
36668       result = (arg1)->GetMaximumSize();
36669     } catch (std::out_of_range& e) {
36670       {
36671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36672       };
36673     } catch (std::exception& e) {
36674       {
36675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36676       };
36677     } catch (Dali::DaliException e) {
36678       {
36679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36680       };
36681     } catch (...) {
36682       {
36683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36684       };
36685     }
36686   }
36687
36688   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36689   return jresult;
36690 }
36691
36692
36693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36694   int jresult ;
36695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36696   int result;
36697
36698   arg1 = (Dali::Actor *)jarg1;
36699   {
36700     try {
36701       result = (int)(arg1)->GetHierarchyDepth();
36702       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36703       if(parent)
36704       {
36705         const std::string parentName = parent.GetName();
36706         if(parentName.compare("rootAbsoluteLayout") == 0)
36707         {
36708           result -= 1;
36709         }
36710       }
36711     } catch (std::out_of_range& e) {
36712       {
36713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36714       };
36715     } catch (std::exception& e) {
36716       {
36717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36718       };
36719     } catch (Dali::DaliException e) {
36720       {
36721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36722       };
36723     } catch (...) {
36724       {
36725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36726       };
36727     }
36728   }
36729
36730   jresult = result;
36731   return jresult;
36732 }
36733
36734
36735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36736   unsigned int jresult ;
36737   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36738   Dali::Renderer *arg2 = 0 ;
36739   unsigned int result;
36740
36741   arg1 = (Dali::Actor *)jarg1;
36742   arg2 = (Dali::Renderer *)jarg2;
36743   if (!arg2) {
36744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36745     return 0;
36746   }
36747   {
36748     try {
36749       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36750     } catch (std::out_of_range& e) {
36751       {
36752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36753       };
36754     } catch (std::exception& e) {
36755       {
36756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36757       };
36758     } catch (Dali::DaliException e) {
36759       {
36760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36761       };
36762     } catch (...) {
36763       {
36764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36765       };
36766     }
36767   }
36768
36769   jresult = result;
36770   return jresult;
36771 }
36772
36773
36774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36775   unsigned int jresult ;
36776   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36777   unsigned int result;
36778
36779   arg1 = (Dali::Actor *)jarg1;
36780   {
36781     try {
36782       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36783     } catch (std::out_of_range& e) {
36784       {
36785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36786       };
36787     } catch (std::exception& e) {
36788       {
36789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36790       };
36791     } catch (Dali::DaliException e) {
36792       {
36793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36794       };
36795     } catch (...) {
36796       {
36797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36798       };
36799     }
36800   }
36801
36802   jresult = result;
36803   return jresult;
36804 }
36805
36806
36807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36808   void * jresult ;
36809   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36810   unsigned int arg2 ;
36811   Dali::Renderer result;
36812
36813   arg1 = (Dali::Actor *)jarg1;
36814   arg2 = (unsigned int)jarg2;
36815   {
36816     try {
36817       result = (arg1)->GetRendererAt(arg2);
36818     } catch (std::out_of_range& e) {
36819       {
36820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36821       };
36822     } catch (std::exception& e) {
36823       {
36824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36825       };
36826     } catch (Dali::DaliException e) {
36827       {
36828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36829       };
36830     } catch (...) {
36831       {
36832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36833       };
36834     }
36835   }
36836
36837   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36838   return jresult;
36839 }
36840
36841
36842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36844   Dali::Renderer *arg2 = 0 ;
36845
36846   arg1 = (Dali::Actor *)jarg1;
36847   arg2 = (Dali::Renderer *)jarg2;
36848   if (!arg2) {
36849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36850     return ;
36851   }
36852   {
36853     try {
36854       (arg1)->RemoveRenderer(*arg2);
36855     } catch (std::out_of_range& e) {
36856       {
36857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36858       };
36859     } catch (std::exception& e) {
36860       {
36861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36862       };
36863     } catch (Dali::DaliException e) {
36864       {
36865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36866       };
36867     } catch (...) {
36868       {
36869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36870       };
36871     }
36872   }
36873
36874 }
36875
36876
36877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36879   unsigned int arg2 ;
36880
36881   arg1 = (Dali::Actor *)jarg1;
36882   arg2 = (unsigned int)jarg2;
36883   {
36884     try {
36885       (arg1)->RemoveRenderer(arg2);
36886     } catch (std::out_of_range& e) {
36887       {
36888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36889       };
36890     } catch (std::exception& e) {
36891       {
36892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36893       };
36894     } catch (Dali::DaliException e) {
36895       {
36896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36897       };
36898     } catch (...) {
36899       {
36900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36901       };
36902     }
36903   }
36904
36905 }
36906
36907
36908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36909   void * jresult ;
36910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36911   Dali::Actor::TouchSignalType *result = 0 ;
36912
36913   arg1 = (Dali::Actor *)jarg1;
36914   {
36915     try {
36916       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36917     } catch (std::out_of_range& e) {
36918       {
36919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36920       };
36921     } catch (std::exception& e) {
36922       {
36923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36924       };
36925     } catch (Dali::DaliException e) {
36926       {
36927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36928       };
36929     } catch (...) {
36930       {
36931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36932       };
36933     }
36934   }
36935
36936   jresult = (void *)result;
36937   return jresult;
36938 }
36939
36940
36941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36942   void * jresult ;
36943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36944   Dali::Actor::TouchDataSignalType *result = 0 ;
36945
36946   arg1 = (Dali::Actor *)jarg1;
36947   {
36948     try {
36949       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36950     } catch (std::out_of_range& e) {
36951       {
36952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36953       };
36954     } catch (std::exception& e) {
36955       {
36956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36957       };
36958     } catch (Dali::DaliException e) {
36959       {
36960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36961       };
36962     } catch (...) {
36963       {
36964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36965       };
36966     }
36967   }
36968
36969   jresult = (void *)result;
36970   return jresult;
36971 }
36972
36973
36974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36975   void * jresult ;
36976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36977   Dali::Actor::HoverSignalType *result = 0 ;
36978
36979   arg1 = (Dali::Actor *)jarg1;
36980   {
36981     try {
36982       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36983     } catch (std::out_of_range& e) {
36984       {
36985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36986       };
36987     } catch (std::exception& e) {
36988       {
36989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36990       };
36991     } catch (Dali::DaliException e) {
36992       {
36993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36994       };
36995     } catch (...) {
36996       {
36997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36998       };
36999     }
37000   }
37001
37002   jresult = (void *)result;
37003   return jresult;
37004 }
37005
37006
37007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37008   void * jresult ;
37009   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37010   Dali::Actor::WheelEventSignalType *result = 0 ;
37011
37012   arg1 = (Dali::Actor *)jarg1;
37013   {
37014     try {
37015       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37016     } catch (std::out_of_range& e) {
37017       {
37018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37019       };
37020     } catch (std::exception& e) {
37021       {
37022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37023       };
37024     } catch (Dali::DaliException e) {
37025       {
37026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37027       };
37028     } catch (...) {
37029       {
37030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37031       };
37032     }
37033   }
37034
37035   jresult = (void *)result;
37036   return jresult;
37037 }
37038
37039
37040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37041   void * jresult ;
37042   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37043   Dali::Actor::OnStageSignalType *result = 0 ;
37044
37045   arg1 = (Dali::Actor *)jarg1;
37046   {
37047     try {
37048       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37049     } catch (std::out_of_range& e) {
37050       {
37051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37052       };
37053     } catch (std::exception& e) {
37054       {
37055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37056       };
37057     } catch (Dali::DaliException e) {
37058       {
37059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37060       };
37061     } catch (...) {
37062       {
37063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37064       };
37065     }
37066   }
37067
37068   jresult = (void *)result;
37069   return jresult;
37070 }
37071
37072
37073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37074   void * jresult ;
37075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37076   Dali::Actor::OffStageSignalType *result = 0 ;
37077
37078   arg1 = (Dali::Actor *)jarg1;
37079   {
37080     try {
37081       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37082     } catch (std::out_of_range& e) {
37083       {
37084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37085       };
37086     } catch (std::exception& e) {
37087       {
37088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37089       };
37090     } catch (Dali::DaliException e) {
37091       {
37092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37093       };
37094     } catch (...) {
37095       {
37096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37097       };
37098     }
37099   }
37100
37101   jresult = (void *)result;
37102   return jresult;
37103 }
37104
37105
37106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37107   void * jresult ;
37108   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37109   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37110
37111   arg1 = (Dali::Actor *)jarg1;
37112   {
37113     try {
37114       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
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 (Dali::DaliException e) {
37124       {
37125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37126       };
37127     } catch (...) {
37128       {
37129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37130       };
37131     }
37132   }
37133
37134   jresult = (void *)result;
37135   return jresult;
37136 }
37137
37138
37139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37140   Dali::Actor *arg1 = 0 ;
37141
37142   arg1 = (Dali::Actor *)jarg1;
37143   if (!arg1) {
37144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37145     return ;
37146   }
37147   {
37148     try {
37149       Dali::UnparentAndReset(*arg1);
37150     } catch (std::out_of_range& e) {
37151       {
37152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37153       };
37154     } catch (std::exception& e) {
37155       {
37156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37157       };
37158     } catch (Dali::DaliException e) {
37159       {
37160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37161       };
37162     } catch (...) {
37163       {
37164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37165       };
37166     }
37167   }
37168
37169 }
37170
37171
37172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37173   int jresult ;
37174   int result;
37175
37176   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37177   jresult = (int)result;
37178   return jresult;
37179 }
37180
37181
37182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37183   int jresult ;
37184   int result;
37185
37186   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37187   jresult = (int)result;
37188   return jresult;
37189 }
37190
37191
37192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37193   int jresult ;
37194   int result;
37195
37196   result = (int)Dali::Layer::Property::BEHAVIOR;
37197   jresult = (int)result;
37198   return jresult;
37199 }
37200
37201
37202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37203   void * jresult ;
37204   Dali::Layer::Property *result = 0 ;
37205
37206   {
37207     try {
37208       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37209     } catch (std::out_of_range& e) {
37210       {
37211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37212       };
37213     } catch (std::exception& e) {
37214       {
37215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37216       };
37217     } catch (Dali::DaliException e) {
37218       {
37219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37220       };
37221     } catch (...) {
37222       {
37223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37224       };
37225     }
37226   }
37227
37228   jresult = (void *)result;
37229   return jresult;
37230 }
37231
37232
37233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37234   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37235
37236   arg1 = (Dali::Layer::Property *)jarg1;
37237   {
37238     try {
37239       delete arg1;
37240     } catch (std::out_of_range& e) {
37241       {
37242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37243       };
37244     } catch (std::exception& e) {
37245       {
37246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37247       };
37248     } catch (Dali::DaliException e) {
37249       {
37250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37251       };
37252     } catch (...) {
37253       {
37254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37255       };
37256     }
37257   }
37258
37259 }
37260
37261
37262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37263   void * jresult ;
37264   Dali::Layer *result = 0 ;
37265
37266   {
37267     try {
37268       result = (Dali::Layer *)new Dali::Layer();
37269     } catch (std::out_of_range& e) {
37270       {
37271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37272       };
37273     } catch (std::exception& e) {
37274       {
37275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37276       };
37277     } catch (Dali::DaliException e) {
37278       {
37279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37280       };
37281     } catch (...) {
37282       {
37283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37284       };
37285     }
37286   }
37287
37288   jresult = (void *)result;
37289   return jresult;
37290 }
37291
37292
37293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37294   void * jresult ;
37295   Dali::Layer result;
37296
37297   {
37298     try {
37299       result = Dali::Layer::New();
37300     } catch (std::out_of_range& e) {
37301       {
37302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37303       };
37304     } catch (std::exception& e) {
37305       {
37306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37307       };
37308     } catch (Dali::DaliException e) {
37309       {
37310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37311       };
37312     } catch (...) {
37313       {
37314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37315       };
37316     }
37317   }
37318
37319   jresult = new Dali::Layer((const Dali::Layer &)result);
37320   return jresult;
37321 }
37322
37323
37324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37325   void * jresult ;
37326   Dali::BaseHandle arg1 ;
37327   Dali::BaseHandle *argp1 ;
37328   Dali::Layer result;
37329
37330   argp1 = (Dali::BaseHandle *)jarg1;
37331   if (!argp1) {
37332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37333     return 0;
37334   }
37335   arg1 = *argp1;
37336   {
37337     try {
37338       result = Dali::Layer::DownCast(arg1);
37339     } catch (std::out_of_range& e) {
37340       {
37341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37342       };
37343     } catch (std::exception& e) {
37344       {
37345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37346       };
37347     } catch (Dali::DaliException e) {
37348       {
37349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37350       };
37351     } catch (...) {
37352       {
37353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37354       };
37355     }
37356   }
37357
37358   jresult = new Dali::Layer((const Dali::Layer &)result);
37359   return jresult;
37360 }
37361
37362
37363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37364   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37365
37366   arg1 = (Dali::Layer *)jarg1;
37367   {
37368     try {
37369       delete arg1;
37370     } catch (std::out_of_range& e) {
37371       {
37372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37373       };
37374     } catch (std::exception& e) {
37375       {
37376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37377       };
37378     } catch (Dali::DaliException e) {
37379       {
37380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37381       };
37382     } catch (...) {
37383       {
37384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37385       };
37386     }
37387   }
37388
37389 }
37390
37391
37392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37393   void * jresult ;
37394   Dali::Layer *arg1 = 0 ;
37395   Dali::Layer *result = 0 ;
37396
37397   arg1 = (Dali::Layer *)jarg1;
37398   if (!arg1) {
37399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37400     return 0;
37401   }
37402   {
37403     try {
37404       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37405     } catch (std::out_of_range& e) {
37406       {
37407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37408       };
37409     } catch (std::exception& e) {
37410       {
37411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37412       };
37413     } catch (Dali::DaliException e) {
37414       {
37415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37416       };
37417     } catch (...) {
37418       {
37419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37420       };
37421     }
37422   }
37423
37424   jresult = (void *)result;
37425   return jresult;
37426 }
37427
37428
37429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37430   void * jresult ;
37431   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37432   Dali::Layer *arg2 = 0 ;
37433   Dali::Layer *result = 0 ;
37434
37435   arg1 = (Dali::Layer *)jarg1;
37436   arg2 = (Dali::Layer *)jarg2;
37437   if (!arg2) {
37438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37439     return 0;
37440   }
37441   {
37442     try {
37443       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37444     } catch (std::out_of_range& e) {
37445       {
37446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37447       };
37448     } catch (std::exception& e) {
37449       {
37450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37451       };
37452     } catch (Dali::DaliException e) {
37453       {
37454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37455       };
37456     } catch (...) {
37457       {
37458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37459       };
37460     }
37461   }
37462
37463   jresult = (void *)result;
37464   return jresult;
37465 }
37466
37467
37468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37469   unsigned int jresult ;
37470   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37471   unsigned int result;
37472
37473   arg1 = (Dali::Layer *)jarg1;
37474   {
37475     try {
37476       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37477     } catch (std::out_of_range& e) {
37478       {
37479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37480       };
37481     } catch (std::exception& e) {
37482       {
37483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37484       };
37485     } catch (Dali::DaliException e) {
37486       {
37487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37488       };
37489     } catch (...) {
37490       {
37491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37492       };
37493     }
37494   }
37495
37496   jresult = result;
37497   return jresult;
37498 }
37499
37500
37501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37502   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37503
37504   arg1 = (Dali::Layer *)jarg1;
37505   {
37506     try {
37507       (arg1)->Raise();
37508     } catch (std::out_of_range& e) {
37509       {
37510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37511       };
37512     } catch (std::exception& e) {
37513       {
37514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37515       };
37516     } catch (Dali::DaliException e) {
37517       {
37518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37519       };
37520     } catch (...) {
37521       {
37522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37523       };
37524     }
37525   }
37526
37527 }
37528
37529
37530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37531   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37532
37533   arg1 = (Dali::Layer *)jarg1;
37534   {
37535     try {
37536       (arg1)->Lower();
37537     } catch (std::out_of_range& e) {
37538       {
37539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37540       };
37541     } catch (std::exception& e) {
37542       {
37543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37544       };
37545     } catch (Dali::DaliException e) {
37546       {
37547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37548       };
37549     } catch (...) {
37550       {
37551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37552       };
37553     }
37554   }
37555
37556 }
37557
37558
37559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37560   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37561   Dali::Layer arg2 ;
37562   Dali::Layer *argp2 ;
37563
37564   arg1 = (Dali::Layer *)jarg1;
37565   argp2 = (Dali::Layer *)jarg2;
37566   if (!argp2) {
37567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37568     return ;
37569   }
37570   arg2 = *argp2;
37571   {
37572     try {
37573       (arg1)->RaiseAbove(arg2);
37574     } catch (std::out_of_range& e) {
37575       {
37576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37577       };
37578     } catch (std::exception& e) {
37579       {
37580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37581       };
37582     } catch (Dali::DaliException e) {
37583       {
37584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37585       };
37586     } catch (...) {
37587       {
37588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37589       };
37590     }
37591   }
37592
37593 }
37594
37595
37596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37597   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37598   Dali::Layer arg2 ;
37599   Dali::Layer *argp2 ;
37600
37601   arg1 = (Dali::Layer *)jarg1;
37602   argp2 = (Dali::Layer *)jarg2;
37603   if (!argp2) {
37604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37605     return ;
37606   }
37607   arg2 = *argp2;
37608   {
37609     try {
37610       (arg1)->LowerBelow(arg2);
37611     } catch (std::out_of_range& e) {
37612       {
37613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37614       };
37615     } catch (std::exception& e) {
37616       {
37617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37618       };
37619     } catch (Dali::DaliException e) {
37620       {
37621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37622       };
37623     } catch (...) {
37624       {
37625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37626       };
37627     }
37628   }
37629
37630 }
37631
37632
37633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37634   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37635
37636   arg1 = (Dali::Layer *)jarg1;
37637   {
37638     try {
37639       (arg1)->RaiseToTop();
37640     } catch (std::out_of_range& e) {
37641       {
37642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37643       };
37644     } catch (std::exception& e) {
37645       {
37646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37647       };
37648     } catch (Dali::DaliException e) {
37649       {
37650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37651       };
37652     } catch (...) {
37653       {
37654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37655       };
37656     }
37657   }
37658
37659 }
37660
37661
37662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37663   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37664
37665   arg1 = (Dali::Layer *)jarg1;
37666   {
37667     try {
37668       (arg1)->LowerToBottom();
37669     } catch (std::out_of_range& e) {
37670       {
37671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37672       };
37673     } catch (std::exception& e) {
37674       {
37675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37676       };
37677     } catch (Dali::DaliException e) {
37678       {
37679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37680       };
37681     } catch (...) {
37682       {
37683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37684       };
37685     }
37686   }
37687
37688 }
37689
37690
37691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37692   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37693   Dali::Layer arg2 ;
37694   Dali::Layer *argp2 ;
37695
37696   arg1 = (Dali::Layer *)jarg1;
37697   argp2 = (Dali::Layer *)jarg2;
37698   if (!argp2) {
37699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37700     return ;
37701   }
37702   arg2 = *argp2;
37703   {
37704     try {
37705       (arg1)->MoveAbove(arg2);
37706     } catch (std::out_of_range& e) {
37707       {
37708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37709       };
37710     } catch (std::exception& e) {
37711       {
37712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37713       };
37714     } catch (Dali::DaliException e) {
37715       {
37716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37717       };
37718     } catch (...) {
37719       {
37720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37721       };
37722     }
37723   }
37724
37725 }
37726
37727
37728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37729   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37730   Dali::Layer arg2 ;
37731   Dali::Layer *argp2 ;
37732
37733   arg1 = (Dali::Layer *)jarg1;
37734   argp2 = (Dali::Layer *)jarg2;
37735   if (!argp2) {
37736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37737     return ;
37738   }
37739   arg2 = *argp2;
37740   {
37741     try {
37742       (arg1)->MoveBelow(arg2);
37743     } catch (std::out_of_range& e) {
37744       {
37745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37746       };
37747     } catch (std::exception& e) {
37748       {
37749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37750       };
37751     } catch (Dali::DaliException e) {
37752       {
37753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37754       };
37755     } catch (...) {
37756       {
37757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37758       };
37759     }
37760   }
37761
37762 }
37763
37764
37765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37766   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37767   Dali::Layer::Behavior arg2 ;
37768
37769   arg1 = (Dali::Layer *)jarg1;
37770   arg2 = (Dali::Layer::Behavior)jarg2;
37771   {
37772     try {
37773       (arg1)->SetBehavior(arg2);
37774     } catch (std::out_of_range& e) {
37775       {
37776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37777       };
37778     } catch (std::exception& e) {
37779       {
37780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37781       };
37782     } catch (Dali::DaliException e) {
37783       {
37784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37785       };
37786     } catch (...) {
37787       {
37788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37789       };
37790     }
37791   }
37792
37793 }
37794
37795
37796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37797   int jresult ;
37798   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37799   Dali::Layer::Behavior result;
37800
37801   arg1 = (Dali::Layer *)jarg1;
37802   {
37803     try {
37804       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37805     } catch (std::out_of_range& e) {
37806       {
37807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37808       };
37809     } catch (std::exception& e) {
37810       {
37811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37812       };
37813     } catch (Dali::DaliException e) {
37814       {
37815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37816       };
37817     } catch (...) {
37818       {
37819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37820       };
37821     }
37822   }
37823
37824   jresult = (int)result;
37825   return jresult;
37826 }
37827
37828
37829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37830   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37831   bool arg2 ;
37832
37833   arg1 = (Dali::Layer *)jarg1;
37834   arg2 = jarg2 ? true : false;
37835   {
37836     try {
37837       (arg1)->SetClipping(arg2);
37838     } catch (std::out_of_range& e) {
37839       {
37840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37841       };
37842     } catch (std::exception& e) {
37843       {
37844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37845       };
37846     } catch (Dali::DaliException e) {
37847       {
37848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37849       };
37850     } catch (...) {
37851       {
37852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37853       };
37854     }
37855   }
37856
37857 }
37858
37859
37860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37861   unsigned int jresult ;
37862   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37863   bool result;
37864
37865   arg1 = (Dali::Layer *)jarg1;
37866   {
37867     try {
37868       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37869     } catch (std::out_of_range& e) {
37870       {
37871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37872       };
37873     } catch (std::exception& e) {
37874       {
37875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37876       };
37877     } catch (Dali::DaliException e) {
37878       {
37879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37880       };
37881     } catch (...) {
37882       {
37883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37884       };
37885     }
37886   }
37887
37888   jresult = result;
37889   return jresult;
37890 }
37891
37892
37893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37894   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37895   int arg2 ;
37896   int arg3 ;
37897   int arg4 ;
37898   int arg5 ;
37899
37900   arg1 = (Dali::Layer *)jarg1;
37901   arg2 = (int)jarg2;
37902   arg3 = (int)jarg3;
37903   arg4 = (int)jarg4;
37904   arg5 = (int)jarg5;
37905   {
37906     try {
37907       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37908     } catch (std::out_of_range& e) {
37909       {
37910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37911       };
37912     } catch (std::exception& e) {
37913       {
37914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37915       };
37916     } catch (Dali::DaliException e) {
37917       {
37918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37919       };
37920     } catch (...) {
37921       {
37922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37923       };
37924     }
37925   }
37926
37927 }
37928
37929
37930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37931   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37932   Dali::ClippingBox arg2 ;
37933   Dali::ClippingBox *argp2 ;
37934
37935   arg1 = (Dali::Layer *)jarg1;
37936   argp2 = (Dali::ClippingBox *)jarg2;
37937   if (!argp2) {
37938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37939     return ;
37940   }
37941   arg2 = *argp2;
37942   {
37943     try {
37944       (arg1)->SetClippingBox(arg2);
37945     } catch (std::out_of_range& e) {
37946       {
37947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37948       };
37949     } catch (std::exception& e) {
37950       {
37951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37952       };
37953     } catch (Dali::DaliException e) {
37954       {
37955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37956       };
37957     } catch (...) {
37958       {
37959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37960       };
37961     }
37962   }
37963
37964 }
37965
37966
37967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37968   void * jresult ;
37969   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37970   Dali::ClippingBox result;
37971
37972   arg1 = (Dali::Layer *)jarg1;
37973   {
37974     try {
37975       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37976     } catch (std::out_of_range& e) {
37977       {
37978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37979       };
37980     } catch (std::exception& e) {
37981       {
37982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37983       };
37984     } catch (Dali::DaliException e) {
37985       {
37986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37987       };
37988     } catch (...) {
37989       {
37990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37991       };
37992     }
37993   }
37994
37995   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37996   return jresult;
37997 }
37998
37999
38000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38001   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38002   bool arg2 ;
38003
38004   arg1 = (Dali::Layer *)jarg1;
38005   arg2 = jarg2 ? true : false;
38006   {
38007     try {
38008       (arg1)->SetDepthTestDisabled(arg2);
38009     } catch (std::out_of_range& e) {
38010       {
38011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38012       };
38013     } catch (std::exception& e) {
38014       {
38015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38016       };
38017     } catch (Dali::DaliException e) {
38018       {
38019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38020       };
38021     } catch (...) {
38022       {
38023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38024       };
38025     }
38026   }
38027
38028 }
38029
38030
38031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38032   unsigned int jresult ;
38033   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38034   bool result;
38035
38036   arg1 = (Dali::Layer *)jarg1;
38037   {
38038     try {
38039       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38040     } catch (std::out_of_range& e) {
38041       {
38042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38043       };
38044     } catch (std::exception& e) {
38045       {
38046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38047       };
38048     } catch (Dali::DaliException e) {
38049       {
38050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38051       };
38052     } catch (...) {
38053       {
38054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38055       };
38056     }
38057   }
38058
38059   jresult = result;
38060   return jresult;
38061 }
38062
38063
38064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38065   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38066   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38067
38068   arg1 = (Dali::Layer *)jarg1;
38069   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38070   {
38071     try {
38072       (arg1)->SetSortFunction(arg2);
38073     } catch (std::out_of_range& e) {
38074       {
38075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38076       };
38077     } catch (std::exception& e) {
38078       {
38079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38080       };
38081     } catch (Dali::DaliException e) {
38082       {
38083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38084       };
38085     } catch (...) {
38086       {
38087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38088       };
38089     }
38090   }
38091
38092 }
38093
38094
38095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38096   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38097   bool arg2 ;
38098
38099   arg1 = (Dali::Layer *)jarg1;
38100   arg2 = jarg2 ? true : false;
38101   {
38102     try {
38103       (arg1)->SetTouchConsumed(arg2);
38104     } catch (std::out_of_range& e) {
38105       {
38106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38107       };
38108     } catch (std::exception& e) {
38109       {
38110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38111       };
38112     } catch (Dali::DaliException e) {
38113       {
38114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38115       };
38116     } catch (...) {
38117       {
38118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38119       };
38120     }
38121   }
38122
38123 }
38124
38125
38126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38127   unsigned int jresult ;
38128   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38129   bool result;
38130
38131   arg1 = (Dali::Layer *)jarg1;
38132   {
38133     try {
38134       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38135     } catch (std::out_of_range& e) {
38136       {
38137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38138       };
38139     } catch (std::exception& e) {
38140       {
38141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38142       };
38143     } catch (Dali::DaliException e) {
38144       {
38145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38146       };
38147     } catch (...) {
38148       {
38149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38150       };
38151     }
38152   }
38153
38154   jresult = result;
38155   return jresult;
38156 }
38157
38158
38159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38160   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38161   bool arg2 ;
38162
38163   arg1 = (Dali::Layer *)jarg1;
38164   arg2 = jarg2 ? true : false;
38165   {
38166     try {
38167       (arg1)->SetHoverConsumed(arg2);
38168     } catch (std::out_of_range& e) {
38169       {
38170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38171       };
38172     } catch (std::exception& e) {
38173       {
38174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38175       };
38176     } catch (Dali::DaliException e) {
38177       {
38178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38179       };
38180     } catch (...) {
38181       {
38182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38183       };
38184     }
38185   }
38186
38187 }
38188
38189
38190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38191   unsigned int jresult ;
38192   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38193   bool result;
38194
38195   arg1 = (Dali::Layer *)jarg1;
38196   {
38197     try {
38198       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38199     } catch (std::out_of_range& e) {
38200       {
38201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38202       };
38203     } catch (std::exception& e) {
38204       {
38205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38206       };
38207     } catch (Dali::DaliException e) {
38208       {
38209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38210       };
38211     } catch (...) {
38212       {
38213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38214       };
38215     }
38216   }
38217
38218   jresult = result;
38219   return jresult;
38220 }
38221
38222
38223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38224   void * jresult ;
38225   Dali::Vector4 *result = 0 ;
38226
38227   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38228   jresult = (void *)result;
38229   return jresult;
38230 }
38231
38232
38233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38234   void * jresult ;
38235   Dali::Vector4 *result = 0 ;
38236
38237   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38238   jresult = (void *)result;
38239   return jresult;
38240 }
38241
38242
38243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38244   void * jresult ;
38245   Dali::Stage *result = 0 ;
38246
38247   {
38248     try {
38249       result = (Dali::Stage *)new Dali::Stage();
38250     } catch (std::out_of_range& e) {
38251       {
38252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38253       };
38254     } catch (std::exception& e) {
38255       {
38256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38257       };
38258     } catch (Dali::DaliException e) {
38259       {
38260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38261       };
38262     } catch (...) {
38263       {
38264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38265       };
38266     }
38267   }
38268
38269   jresult = (void *)result;
38270   return jresult;
38271 }
38272
38273
38274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38275   void * jresult ;
38276   Dali::Stage result;
38277
38278   {
38279     try {
38280       result = Dali::Stage::GetCurrent();
38281     } catch (std::out_of_range& e) {
38282       {
38283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38284       };
38285     } catch (std::exception& e) {
38286       {
38287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38288       };
38289     } catch (Dali::DaliException e) {
38290       {
38291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38292       };
38293     } catch (...) {
38294       {
38295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38296       };
38297     }
38298   }
38299
38300   jresult = new Dali::Stage((const Dali::Stage &)result);
38301   return jresult;
38302 }
38303
38304
38305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38306   unsigned int jresult ;
38307   bool result;
38308
38309   {
38310     try {
38311       result = (bool)Dali::Stage::IsInstalled();
38312     } catch (std::out_of_range& e) {
38313       {
38314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38315       };
38316     } catch (std::exception& e) {
38317       {
38318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38319       };
38320     } catch (Dali::DaliException e) {
38321       {
38322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38323       };
38324     } catch (...) {
38325       {
38326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38327       };
38328     }
38329   }
38330
38331   jresult = result;
38332   return jresult;
38333 }
38334
38335
38336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38337   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38338
38339   arg1 = (Dali::Stage *)jarg1;
38340   {
38341     try {
38342       delete arg1;
38343     } catch (std::out_of_range& e) {
38344       {
38345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38346       };
38347     } catch (std::exception& e) {
38348       {
38349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38350       };
38351     } catch (Dali::DaliException e) {
38352       {
38353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38354       };
38355     } catch (...) {
38356       {
38357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38358       };
38359     }
38360   }
38361
38362 }
38363
38364
38365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38366   void * jresult ;
38367   Dali::Stage *arg1 = 0 ;
38368   Dali::Stage *result = 0 ;
38369
38370   arg1 = (Dali::Stage *)jarg1;
38371   if (!arg1) {
38372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38373     return 0;
38374   }
38375   {
38376     try {
38377       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38378     } catch (std::out_of_range& e) {
38379       {
38380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38381       };
38382     } catch (std::exception& e) {
38383       {
38384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38385       };
38386     } catch (Dali::DaliException e) {
38387       {
38388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38389       };
38390     } catch (...) {
38391       {
38392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38393       };
38394     }
38395   }
38396
38397   jresult = (void *)result;
38398   return jresult;
38399 }
38400
38401
38402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38403   void * jresult ;
38404   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38405   Dali::Stage *arg2 = 0 ;
38406   Dali::Stage *result = 0 ;
38407
38408   arg1 = (Dali::Stage *)jarg1;
38409   arg2 = (Dali::Stage *)jarg2;
38410   if (!arg2) {
38411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38412     return 0;
38413   }
38414   {
38415     try {
38416       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38417     } catch (std::out_of_range& e) {
38418       {
38419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38420       };
38421     } catch (std::exception& e) {
38422       {
38423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38424       };
38425     } catch (Dali::DaliException e) {
38426       {
38427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38428       };
38429     } catch (...) {
38430       {
38431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38432       };
38433     }
38434   }
38435
38436   jresult = (void *)result;
38437   return jresult;
38438 }
38439
38440
38441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38442   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38443   Dali::Actor *arg2 = 0 ;
38444
38445   arg1 = (Dali::Stage *)jarg1;
38446   arg2 = (Dali::Actor *)jarg2;
38447   if (!arg2) {
38448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38449     return ;
38450   }
38451   {
38452     try {
38453       (arg1)->Add(*arg2);
38454     } catch (std::out_of_range& e) {
38455       {
38456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38457       };
38458     } catch (std::exception& e) {
38459       {
38460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38461       };
38462     } catch (Dali::DaliException e) {
38463       {
38464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38465       };
38466     } catch (...) {
38467       {
38468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38469       };
38470     }
38471   }
38472
38473 }
38474
38475
38476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38477   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38478   Dali::Actor *arg2 = 0 ;
38479
38480   arg1 = (Dali::Stage *)jarg1;
38481   arg2 = (Dali::Actor *)jarg2;
38482   if (!arg2) {
38483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38484     return ;
38485   }
38486   {
38487     try {
38488       (arg1)->Remove(*arg2);
38489     } catch (std::out_of_range& e) {
38490       {
38491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38492       };
38493     } catch (std::exception& e) {
38494       {
38495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38496       };
38497     } catch (Dali::DaliException e) {
38498       {
38499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38500       };
38501     } catch (...) {
38502       {
38503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38504       };
38505     }
38506   }
38507
38508 }
38509
38510
38511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38512   void * jresult ;
38513   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38514   Dali::Vector2 result;
38515
38516   arg1 = (Dali::Stage *)jarg1;
38517   {
38518     try {
38519       result = ((Dali::Stage const *)arg1)->GetSize();
38520     } catch (std::out_of_range& e) {
38521       {
38522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38523       };
38524     } catch (std::exception& e) {
38525       {
38526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38527       };
38528     } catch (Dali::DaliException e) {
38529       {
38530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38531       };
38532     } catch (...) {
38533       {
38534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38535       };
38536     }
38537   }
38538
38539   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38540   return jresult;
38541 }
38542
38543
38544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38545   void * jresult ;
38546   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38547   Dali::RenderTaskList result;
38548
38549   arg1 = (Dali::Stage *)jarg1;
38550   {
38551     try {
38552       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38553     } catch (std::out_of_range& e) {
38554       {
38555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38556       };
38557     } catch (std::exception& e) {
38558       {
38559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38560       };
38561     } catch (Dali::DaliException e) {
38562       {
38563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38564       };
38565     } catch (...) {
38566       {
38567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38568       };
38569     }
38570   }
38571
38572   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38573   return jresult;
38574 }
38575
38576
38577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38578   unsigned int jresult ;
38579   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38580   unsigned int result;
38581
38582   arg1 = (Dali::Stage *)jarg1;
38583   {
38584     try {
38585       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38586     } catch (std::out_of_range& e) {
38587       {
38588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38589       };
38590     } catch (std::exception& e) {
38591       {
38592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38593       };
38594     } catch (Dali::DaliException e) {
38595       {
38596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38597       };
38598     } catch (...) {
38599       {
38600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38601       };
38602     }
38603   }
38604
38605   jresult = result;
38606   return jresult;
38607 }
38608
38609
38610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38611   void * jresult ;
38612   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38613   unsigned int arg2 ;
38614   Dali::Layer result;
38615
38616   arg1 = (Dali::Stage *)jarg1;
38617   arg2 = (unsigned int)jarg2;
38618   {
38619     try {
38620       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38621     } catch (std::out_of_range& e) {
38622       {
38623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38624       };
38625     } catch (std::exception& e) {
38626       {
38627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38628       };
38629     } catch (Dali::DaliException e) {
38630       {
38631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38632       };
38633     } catch (...) {
38634       {
38635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38636       };
38637     }
38638   }
38639
38640   jresult = new Dali::Layer((const Dali::Layer &)result);
38641   return jresult;
38642 }
38643
38644
38645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38646   void * jresult ;
38647   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38648   Dali::Layer result;
38649
38650   arg1 = (Dali::Stage *)jarg1;
38651   {
38652     try {
38653       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38654     } catch (std::out_of_range& e) {
38655       {
38656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38657       };
38658     } catch (std::exception& e) {
38659       {
38660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38661       };
38662     } catch (Dali::DaliException e) {
38663       {
38664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38665       };
38666     } catch (...) {
38667       {
38668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38669       };
38670     }
38671   }
38672
38673   jresult = new Dali::Layer((const Dali::Layer &)result);
38674   return jresult;
38675 }
38676
38677
38678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38679   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38680   Dali::Vector4 arg2 ;
38681   Dali::Vector4 *argp2 ;
38682
38683   arg1 = (Dali::Stage *)jarg1;
38684   argp2 = (Dali::Vector4 *)jarg2;
38685   if (!argp2) {
38686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38687     return ;
38688   }
38689   arg2 = *argp2;
38690   {
38691     try {
38692       (arg1)->SetBackgroundColor(arg2);
38693     } catch (std::out_of_range& e) {
38694       {
38695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38696       };
38697     } catch (std::exception& e) {
38698       {
38699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38700       };
38701     } catch (Dali::DaliException e) {
38702       {
38703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38704       };
38705     } catch (...) {
38706       {
38707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38708       };
38709     }
38710   }
38711
38712 }
38713
38714
38715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38716   void * jresult ;
38717   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38718   Dali::Vector4 result;
38719
38720   arg1 = (Dali::Stage *)jarg1;
38721   {
38722     try {
38723       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38724     } catch (std::out_of_range& e) {
38725       {
38726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38727       };
38728     } catch (std::exception& e) {
38729       {
38730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38731       };
38732     } catch (Dali::DaliException e) {
38733       {
38734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38735       };
38736     } catch (...) {
38737       {
38738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38739       };
38740     }
38741   }
38742
38743   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38744   return jresult;
38745 }
38746
38747
38748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38749   void * jresult ;
38750   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38751   Dali::Vector2 result;
38752
38753   arg1 = (Dali::Stage *)jarg1;
38754   {
38755     try {
38756       result = ((Dali::Stage const *)arg1)->GetDpi();
38757     } catch (std::out_of_range& e) {
38758       {
38759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38760       };
38761     } catch (std::exception& e) {
38762       {
38763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38764       };
38765     } catch (Dali::DaliException e) {
38766       {
38767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38768       };
38769     } catch (...) {
38770       {
38771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38772       };
38773     }
38774   }
38775
38776   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38777   return jresult;
38778 }
38779
38780
38781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38782   void * jresult ;
38783   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38784   Dali::ObjectRegistry result;
38785
38786   arg1 = (Dali::Stage *)jarg1;
38787   {
38788     try {
38789       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38790     } catch (std::out_of_range& e) {
38791       {
38792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38793       };
38794     } catch (std::exception& e) {
38795       {
38796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38797       };
38798     } catch (Dali::DaliException e) {
38799       {
38800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38801       };
38802     } catch (...) {
38803       {
38804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38805       };
38806     }
38807   }
38808
38809   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38810   return jresult;
38811 }
38812
38813
38814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38815   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38816   float arg2 ;
38817
38818   arg1 = (Dali::Stage *)jarg1;
38819   arg2 = (float)jarg2;
38820   {
38821     try {
38822       (arg1)->KeepRendering(arg2);
38823     } catch (std::out_of_range& e) {
38824       {
38825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38826       };
38827     } catch (std::exception& e) {
38828       {
38829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38830       };
38831     } catch (Dali::DaliException e) {
38832       {
38833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38834       };
38835     } catch (...) {
38836       {
38837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38838       };
38839     }
38840   }
38841
38842 }
38843
38844
38845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38846   void * jresult ;
38847   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38848   Dali::Stage::KeyEventSignalType *result = 0 ;
38849
38850   arg1 = (Dali::Stage *)jarg1;
38851   {
38852     try {
38853       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38854     } catch (std::out_of_range& e) {
38855       {
38856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38857       };
38858     } catch (std::exception& e) {
38859       {
38860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38861       };
38862     } catch (Dali::DaliException e) {
38863       {
38864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38865       };
38866     } catch (...) {
38867       {
38868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38869       };
38870     }
38871   }
38872
38873   jresult = (void *)result;
38874   return jresult;
38875 }
38876
38877
38878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38879   void * jresult ;
38880   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38881   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38882
38883   arg1 = (Dali::Stage *)jarg1;
38884   {
38885     try {
38886       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38887     } catch (std::out_of_range& e) {
38888       {
38889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38890       };
38891     } catch (std::exception& e) {
38892       {
38893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38894       };
38895     } catch (Dali::DaliException e) {
38896       {
38897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38898       };
38899     } catch (...) {
38900       {
38901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38902       };
38903     }
38904   }
38905
38906   jresult = (void *)result;
38907   return jresult;
38908 }
38909
38910
38911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38912   void * jresult ;
38913   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38914   Dali::Stage::TouchSignalType *result = 0 ;
38915
38916   arg1 = (Dali::Stage *)jarg1;
38917   {
38918     try {
38919       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38920     } catch (std::out_of_range& e) {
38921       {
38922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38923       };
38924     } catch (std::exception& e) {
38925       {
38926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38927       };
38928     } catch (Dali::DaliException e) {
38929       {
38930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38931       };
38932     } catch (...) {
38933       {
38934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38935       };
38936     }
38937   }
38938
38939   jresult = (void *)result;
38940   return jresult;
38941 }
38942
38943
38944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38945   void * jresult ;
38946   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38947   Dali::Stage::WheelEventSignalType *result = 0 ;
38948
38949   arg1 = (Dali::Stage *)jarg1;
38950   {
38951     try {
38952       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38953     } catch (std::out_of_range& e) {
38954       {
38955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38956       };
38957     } catch (std::exception& e) {
38958       {
38959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38960       };
38961     } catch (Dali::DaliException e) {
38962       {
38963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38964       };
38965     } catch (...) {
38966       {
38967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38968       };
38969     }
38970   }
38971
38972   jresult = (void *)result;
38973   return jresult;
38974 }
38975
38976
38977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38978   void * jresult ;
38979   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38980   Dali::Stage::ContextStatusSignal *result = 0 ;
38981
38982   arg1 = (Dali::Stage *)jarg1;
38983   {
38984     try {
38985       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38986     } catch (std::out_of_range& e) {
38987       {
38988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38989       };
38990     } catch (std::exception& e) {
38991       {
38992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38993       };
38994     } catch (Dali::DaliException e) {
38995       {
38996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38997       };
38998     } catch (...) {
38999       {
39000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39001       };
39002     }
39003   }
39004
39005   jresult = (void *)result;
39006   return jresult;
39007 }
39008
39009
39010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39011   void * jresult ;
39012   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39013   Dali::Stage::ContextStatusSignal *result = 0 ;
39014
39015   arg1 = (Dali::Stage *)jarg1;
39016   {
39017     try {
39018       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39019     } catch (std::out_of_range& e) {
39020       {
39021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39022       };
39023     } catch (std::exception& e) {
39024       {
39025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39026       };
39027     } catch (Dali::DaliException e) {
39028       {
39029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39030       };
39031     } catch (...) {
39032       {
39033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39034       };
39035     }
39036   }
39037
39038   jresult = (void *)result;
39039   return jresult;
39040 }
39041
39042
39043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39044   void * jresult ;
39045   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39046   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39047
39048   arg1 = (Dali::Stage *)jarg1;
39049   {
39050     try {
39051       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39052     } catch (std::out_of_range& e) {
39053       {
39054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39055       };
39056     } catch (std::exception& e) {
39057       {
39058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39059       };
39060     } catch (Dali::DaliException e) {
39061       {
39062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39063       };
39064     } catch (...) {
39065       {
39066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39067       };
39068     }
39069   }
39070
39071   jresult = (void *)result;
39072   return jresult;
39073 }
39074
39075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39076   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39077   Dali::DevelStage::Rendering arg2 ;
39078
39079   arg1 = (Dali::Stage *)jarg1;
39080   arg2 = (Dali::DevelStage::Rendering)jarg2;
39081   {
39082     try {
39083       DevelStage::SetRenderingBehavior(*arg1,arg2);
39084     } catch (std::out_of_range& e) {
39085       {
39086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39087       };
39088     } catch (std::exception& e) {
39089       {
39090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39091       };
39092     } catch (Dali::DaliException e) {
39093       {
39094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39095       };
39096     } catch (...) {
39097       {
39098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39099       };
39100     }
39101   }
39102
39103 }
39104
39105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39106
39107   int jresult ;
39108   int result ;
39109   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39110
39111   arg1 = (Dali::Stage *)jarg1;
39112   {
39113     try {
39114       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39115     } catch (std::out_of_range& e) {
39116       {
39117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39118       };
39119     } catch (std::exception& e) {
39120       {
39121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39122       };
39123     } catch (Dali::DaliException e) {
39124       {
39125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39126       };
39127     } catch (...) {
39128       {
39129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39130       };
39131     }
39132   }
39133
39134   jresult = result;
39135   return jresult;
39136 }
39137
39138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39139   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39140
39141   arg1 = (Dali::RelayoutContainer *)jarg1;
39142   {
39143     try {
39144       delete arg1;
39145     } catch (std::out_of_range& e) {
39146       {
39147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39148       };
39149     } catch (std::exception& e) {
39150       {
39151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39152       };
39153     } catch (Dali::DaliException e) {
39154       {
39155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39156       };
39157     } catch (...) {
39158       {
39159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39160       };
39161     }
39162   }
39163
39164 }
39165
39166
39167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39168   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39169   Dali::Actor *arg2 = 0 ;
39170   Dali::Vector2 *arg3 = 0 ;
39171
39172   arg1 = (Dali::RelayoutContainer *)jarg1;
39173   arg2 = (Dali::Actor *)jarg2;
39174   if (!arg2) {
39175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39176     return ;
39177   }
39178   arg3 = (Dali::Vector2 *)jarg3;
39179   if (!arg3) {
39180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39181     return ;
39182   }
39183   {
39184     try {
39185       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39186     } catch (std::out_of_range& e) {
39187       {
39188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39189       };
39190     } catch (std::exception& e) {
39191       {
39192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39193       };
39194     } catch (Dali::DaliException e) {
39195       {
39196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39197       };
39198     } catch (...) {
39199       {
39200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39201       };
39202     }
39203   }
39204
39205 }
39206
39207
39208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39209   void * jresult ;
39210   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39211   Dali::CustomActor result;
39212
39213   arg1 = (Dali::CustomActorImpl *)jarg1;
39214   {
39215     try {
39216       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39217     } catch (std::out_of_range& e) {
39218       {
39219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39220       };
39221     } catch (std::exception& e) {
39222       {
39223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39224       };
39225     } catch (Dali::DaliException e) {
39226       {
39227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39228       };
39229     } catch (...) {
39230       {
39231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39232       };
39233     }
39234   }
39235
39236   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39237   return jresult;
39238 }
39239
39240
39241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39242   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39243   int arg2 ;
39244
39245   arg1 = (Dali::CustomActorImpl *)jarg1;
39246   arg2 = (int)jarg2;
39247   {
39248     try {
39249       (arg1)->OnStageConnection(arg2);
39250     } catch (std::out_of_range& e) {
39251       {
39252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39253       };
39254     } catch (std::exception& e) {
39255       {
39256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39257       };
39258     } catch (Dali::DaliException e) {
39259       {
39260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39261       };
39262     } catch (...) {
39263       {
39264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39265       };
39266     }
39267   }
39268
39269 }
39270
39271
39272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39273   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39274
39275   arg1 = (Dali::CustomActorImpl *)jarg1;
39276   {
39277     try {
39278       (arg1)->OnStageDisconnection();
39279     } catch (std::out_of_range& e) {
39280       {
39281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39282       };
39283     } catch (std::exception& e) {
39284       {
39285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39286       };
39287     } catch (Dali::DaliException e) {
39288       {
39289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39290       };
39291     } catch (...) {
39292       {
39293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39294       };
39295     }
39296   }
39297
39298 }
39299
39300
39301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39302   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39303   Dali::Actor *arg2 = 0 ;
39304
39305   arg1 = (Dali::CustomActorImpl *)jarg1;
39306   arg2 = (Dali::Actor *)jarg2;
39307   if (!arg2) {
39308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39309     return ;
39310   }
39311   {
39312     try {
39313       (arg1)->OnChildAdd(*arg2);
39314     } catch (std::out_of_range& e) {
39315       {
39316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39317       };
39318     } catch (std::exception& e) {
39319       {
39320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39321       };
39322     } catch (Dali::DaliException e) {
39323       {
39324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39325       };
39326     } catch (...) {
39327       {
39328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39329       };
39330     }
39331   }
39332
39333 }
39334
39335
39336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39337   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39338   Dali::Actor *arg2 = 0 ;
39339
39340   arg1 = (Dali::CustomActorImpl *)jarg1;
39341   arg2 = (Dali::Actor *)jarg2;
39342   if (!arg2) {
39343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39344     return ;
39345   }
39346   {
39347     try {
39348       (arg1)->OnChildRemove(*arg2);
39349     } catch (std::out_of_range& e) {
39350       {
39351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39352       };
39353     } catch (std::exception& e) {
39354       {
39355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39356       };
39357     } catch (Dali::DaliException e) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39360       };
39361     } catch (...) {
39362       {
39363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39364       };
39365     }
39366   }
39367
39368 }
39369
39370
39371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39372   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39373   Dali::Property::Index arg2 ;
39374   Dali::Property::Value arg3 ;
39375   Dali::Property::Value *argp3 ;
39376
39377   arg1 = (Dali::CustomActorImpl *)jarg1;
39378   arg2 = (Dali::Property::Index)jarg2;
39379   argp3 = (Dali::Property::Value *)jarg3;
39380   if (!argp3) {
39381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39382     return ;
39383   }
39384   arg3 = *argp3;
39385   {
39386     try {
39387       (arg1)->OnPropertySet(arg2,arg3);
39388     } catch (std::out_of_range& e) {
39389       {
39390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39391       };
39392     } catch (std::exception& e) {
39393       {
39394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39395       };
39396     } catch (Dali::DaliException e) {
39397       {
39398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39399       };
39400     } catch (...) {
39401       {
39402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39403       };
39404     }
39405   }
39406
39407 }
39408
39409
39410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39411   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39412   Dali::Vector3 *arg2 = 0 ;
39413
39414   arg1 = (Dali::CustomActorImpl *)jarg1;
39415   arg2 = (Dali::Vector3 *)jarg2;
39416   if (!arg2) {
39417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39418     return ;
39419   }
39420   {
39421     try {
39422       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39423     } catch (std::out_of_range& e) {
39424       {
39425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39426       };
39427     } catch (std::exception& e) {
39428       {
39429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39430       };
39431     } catch (Dali::DaliException e) {
39432       {
39433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39434       };
39435     } catch (...) {
39436       {
39437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39438       };
39439     }
39440   }
39441
39442 }
39443
39444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39445   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39446   Dali::Animation *arg2 = 0 ;
39447   Dali::Vector3 *arg3 = 0 ;
39448
39449   arg1 = (Dali::CustomActorImpl *)jarg1;
39450   arg2 = (Dali::Animation *)jarg2;
39451   if (!arg2) {
39452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39453     return ;
39454   }
39455   arg3 = (Dali::Vector3 *)jarg3;
39456   if (!arg3) {
39457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39458     return ;
39459   }
39460   {
39461     try {
39462       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39463     } catch (std::out_of_range& e) {
39464       {
39465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39466       };
39467     } catch (std::exception& e) {
39468       {
39469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39470       };
39471     } catch (Dali::DaliException e) {
39472       {
39473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39474       };
39475     } catch (...) {
39476       {
39477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39478       };
39479     }
39480   }
39481
39482 }
39483
39484
39485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39486   unsigned int jresult ;
39487   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39488   Dali::TouchEvent *arg2 = 0 ;
39489   bool result;
39490
39491   arg1 = (Dali::CustomActorImpl *)jarg1;
39492   arg2 = (Dali::TouchEvent *)jarg2;
39493   if (!arg2) {
39494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39495     return 0;
39496   }
39497   {
39498     try {
39499       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39500     } catch (std::out_of_range& e) {
39501       {
39502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39503       };
39504     } catch (std::exception& e) {
39505       {
39506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39507       };
39508     } catch (Dali::DaliException e) {
39509       {
39510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39511       };
39512     } catch (...) {
39513       {
39514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39515       };
39516     }
39517   }
39518
39519   jresult = result;
39520   return jresult;
39521 }
39522
39523
39524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39525   unsigned int jresult ;
39526   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39527   Dali::HoverEvent *arg2 = 0 ;
39528   bool result;
39529
39530   arg1 = (Dali::CustomActorImpl *)jarg1;
39531   arg2 = (Dali::HoverEvent *)jarg2;
39532   if (!arg2) {
39533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39534     return 0;
39535   }
39536   {
39537     try {
39538       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39539     } catch (std::out_of_range& e) {
39540       {
39541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39542       };
39543     } catch (std::exception& e) {
39544       {
39545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39546       };
39547     } catch (Dali::DaliException e) {
39548       {
39549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39550       };
39551     } catch (...) {
39552       {
39553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39554       };
39555     }
39556   }
39557
39558   jresult = result;
39559   return jresult;
39560 }
39561
39562
39563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39564   unsigned int jresult ;
39565   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39566   Dali::KeyEvent *arg2 = 0 ;
39567   bool result;
39568
39569   arg1 = (Dali::CustomActorImpl *)jarg1;
39570   arg2 = (Dali::KeyEvent *)jarg2;
39571   if (!arg2) {
39572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39573     return 0;
39574   }
39575   {
39576     try {
39577       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39578     } catch (std::out_of_range& e) {
39579       {
39580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39581       };
39582     } catch (std::exception& e) {
39583       {
39584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39585       };
39586     } catch (Dali::DaliException e) {
39587       {
39588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39589       };
39590     } catch (...) {
39591       {
39592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39593       };
39594     }
39595   }
39596
39597   jresult = result;
39598   return jresult;
39599 }
39600
39601
39602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39603   unsigned int jresult ;
39604   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39605   Dali::WheelEvent *arg2 = 0 ;
39606   bool result;
39607
39608   arg1 = (Dali::CustomActorImpl *)jarg1;
39609   arg2 = (Dali::WheelEvent *)jarg2;
39610   if (!arg2) {
39611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39612     return 0;
39613   }
39614   {
39615     try {
39616       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39617     } catch (std::out_of_range& e) {
39618       {
39619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39620       };
39621     } catch (std::exception& e) {
39622       {
39623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (Dali::DaliException e) {
39626       {
39627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39628       };
39629     } catch (...) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39632       };
39633     }
39634   }
39635
39636   jresult = result;
39637   return jresult;
39638 }
39639
39640
39641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39642   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39643   Dali::Vector2 *arg2 = 0 ;
39644   Dali::RelayoutContainer *arg3 = 0 ;
39645
39646   arg1 = (Dali::CustomActorImpl *)jarg1;
39647   arg2 = (Dali::Vector2 *)jarg2;
39648   if (!arg2) {
39649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39650     return ;
39651   }
39652   arg3 = (Dali::RelayoutContainer *)jarg3;
39653   if (!arg3) {
39654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39655     return ;
39656   }
39657   {
39658     try {
39659       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39660     } catch (std::out_of_range& e) {
39661       {
39662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39663       };
39664     } catch (std::exception& e) {
39665       {
39666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39667       };
39668     } catch (Dali::DaliException e) {
39669       {
39670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39671       };
39672     } catch (...) {
39673       {
39674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39675       };
39676     }
39677   }
39678
39679 }
39680
39681
39682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39683   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39684   Dali::ResizePolicy::Type arg2 ;
39685   Dali::Dimension::Type arg3 ;
39686
39687   arg1 = (Dali::CustomActorImpl *)jarg1;
39688   arg2 = (Dali::ResizePolicy::Type)jarg2;
39689   arg3 = (Dali::Dimension::Type)jarg3;
39690   {
39691     try {
39692       (arg1)->OnSetResizePolicy(arg2,arg3);
39693     } catch (std::out_of_range& e) {
39694       {
39695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39696       };
39697     } catch (std::exception& e) {
39698       {
39699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39700       };
39701     } catch (Dali::DaliException e) {
39702       {
39703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39704       };
39705     } catch (...) {
39706       {
39707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39708       };
39709     }
39710   }
39711
39712 }
39713
39714
39715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39716   void * jresult ;
39717   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39718   Dali::Vector3 result;
39719
39720   arg1 = (Dali::CustomActorImpl *)jarg1;
39721   {
39722     try {
39723       result = (arg1)->GetNaturalSize();
39724     } catch (std::out_of_range& e) {
39725       {
39726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39727       };
39728     } catch (std::exception& e) {
39729       {
39730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39731       };
39732     } catch (Dali::DaliException e) {
39733       {
39734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39735       };
39736     } catch (...) {
39737       {
39738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39739       };
39740     }
39741   }
39742
39743   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39744   return jresult;
39745 }
39746
39747
39748 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39749   float jresult ;
39750   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39751   Dali::Actor *arg2 = 0 ;
39752   Dali::Dimension::Type arg3 ;
39753   float result;
39754
39755   arg1 = (Dali::CustomActorImpl *)jarg1;
39756   arg2 = (Dali::Actor *)jarg2;
39757   if (!arg2) {
39758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39759     return 0;
39760   }
39761   arg3 = (Dali::Dimension::Type)jarg3;
39762   {
39763     try {
39764       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39765     } catch (std::out_of_range& e) {
39766       {
39767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39768       };
39769     } catch (std::exception& e) {
39770       {
39771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39772       };
39773     } catch (Dali::DaliException e) {
39774       {
39775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39776       };
39777     } catch (...) {
39778       {
39779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39780       };
39781     }
39782   }
39783
39784   jresult = result;
39785   return jresult;
39786 }
39787
39788
39789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39790   float jresult ;
39791   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39792   float arg2 ;
39793   float result;
39794
39795   arg1 = (Dali::CustomActorImpl *)jarg1;
39796   arg2 = (float)jarg2;
39797   {
39798     try {
39799       result = (float)(arg1)->GetHeightForWidth(arg2);
39800     } catch (std::out_of_range& e) {
39801       {
39802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39803       };
39804     } catch (std::exception& e) {
39805       {
39806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39807       };
39808     } catch (Dali::DaliException e) {
39809       {
39810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39811       };
39812     } catch (...) {
39813       {
39814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39815       };
39816     }
39817   }
39818
39819   jresult = result;
39820   return jresult;
39821 }
39822
39823
39824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39825   float jresult ;
39826   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39827   float arg2 ;
39828   float result;
39829
39830   arg1 = (Dali::CustomActorImpl *)jarg1;
39831   arg2 = (float)jarg2;
39832   {
39833     try {
39834       result = (float)(arg1)->GetWidthForHeight(arg2);
39835     } catch (std::out_of_range& e) {
39836       {
39837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39838       };
39839     } catch (std::exception& e) {
39840       {
39841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39842       };
39843     } catch (Dali::DaliException e) {
39844       {
39845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39846       };
39847     } catch (...) {
39848       {
39849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39850       };
39851     }
39852   }
39853
39854   jresult = result;
39855   return jresult;
39856 }
39857
39858
39859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39860   unsigned int jresult ;
39861   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39862   Dali::Dimension::Type arg2 ;
39863   bool result;
39864
39865   arg1 = (Dali::CustomActorImpl *)jarg1;
39866   arg2 = (Dali::Dimension::Type)jarg2;
39867   {
39868     try {
39869       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39870     } catch (std::out_of_range& e) {
39871       {
39872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39873       };
39874     } catch (std::exception& e) {
39875       {
39876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39877       };
39878     } catch (Dali::DaliException e) {
39879       {
39880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39881       };
39882     } catch (...) {
39883       {
39884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39885       };
39886     }
39887   }
39888
39889   jresult = result;
39890   return jresult;
39891 }
39892
39893
39894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39895   unsigned int jresult ;
39896   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39897   bool result;
39898
39899   arg1 = (Dali::CustomActorImpl *)jarg1;
39900   {
39901     try {
39902       result = (bool)(arg1)->RelayoutDependentOnChildren();
39903     } catch (std::out_of_range& e) {
39904       {
39905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39906       };
39907     } catch (std::exception& e) {
39908       {
39909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39910       };
39911     } catch (Dali::DaliException e) {
39912       {
39913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39914       };
39915     } catch (...) {
39916       {
39917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39918       };
39919     }
39920   }
39921
39922   jresult = result;
39923   return jresult;
39924 }
39925
39926
39927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39928   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39929   Dali::Dimension::Type arg2 ;
39930
39931   arg1 = (Dali::CustomActorImpl *)jarg1;
39932   arg2 = (Dali::Dimension::Type)jarg2;
39933   {
39934     try {
39935       (arg1)->OnCalculateRelayoutSize(arg2);
39936     } catch (std::out_of_range& e) {
39937       {
39938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39939       };
39940     } catch (std::exception& e) {
39941       {
39942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39943       };
39944     } catch (Dali::DaliException e) {
39945       {
39946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39947       };
39948     } catch (...) {
39949       {
39950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39951       };
39952     }
39953   }
39954
39955 }
39956
39957
39958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39959   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39960   float arg2 ;
39961   Dali::Dimension::Type arg3 ;
39962
39963   arg1 = (Dali::CustomActorImpl *)jarg1;
39964   arg2 = (float)jarg2;
39965   arg3 = (Dali::Dimension::Type)jarg3;
39966   {
39967     try {
39968       (arg1)->OnLayoutNegotiated(arg2,arg3);
39969     } catch (std::out_of_range& e) {
39970       {
39971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39972       };
39973     } catch (std::exception& e) {
39974       {
39975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39976       };
39977     } catch (Dali::DaliException e) {
39978       {
39979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39980       };
39981     } catch (...) {
39982       {
39983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39984       };
39985     }
39986   }
39987
39988 }
39989
39990
39991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39992   unsigned int jresult ;
39993   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39994   bool result;
39995
39996   arg1 = (Dali::CustomActorImpl *)jarg1;
39997   {
39998     try {
39999       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40000     } catch (std::out_of_range& e) {
40001       {
40002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40003       };
40004     } catch (std::exception& e) {
40005       {
40006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40007       };
40008     } catch (Dali::DaliException e) {
40009       {
40010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40011       };
40012     } catch (...) {
40013       {
40014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40015       };
40016     }
40017   }
40018
40019   jresult = result;
40020   return jresult;
40021 }
40022
40023
40024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40025   unsigned int jresult ;
40026   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40027   bool result;
40028
40029   arg1 = (Dali::CustomActorImpl *)jarg1;
40030   {
40031     try {
40032       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40033     } catch (std::out_of_range& e) {
40034       {
40035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40036       };
40037     } catch (std::exception& e) {
40038       {
40039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40040       };
40041     } catch (Dali::DaliException e) {
40042       {
40043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40044       };
40045     } catch (...) {
40046       {
40047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40048       };
40049     }
40050   }
40051
40052   jresult = result;
40053   return jresult;
40054 }
40055
40056
40057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40058   unsigned int jresult ;
40059   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40060   bool result;
40061
40062   arg1 = (Dali::CustomActorImpl *)jarg1;
40063   {
40064     try {
40065       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40066     } catch (std::out_of_range& e) {
40067       {
40068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40069       };
40070     } catch (std::exception& e) {
40071       {
40072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40073       };
40074     } catch (Dali::DaliException e) {
40075       {
40076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40077       };
40078     } catch (...) {
40079       {
40080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40081       };
40082     }
40083   }
40084
40085   jresult = result;
40086   return jresult;
40087 }
40088
40089
40090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40091   unsigned int jresult ;
40092   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40093   bool result;
40094
40095   arg1 = (Dali::CustomActorImpl *)jarg1;
40096   {
40097     try {
40098       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40099     } catch (std::out_of_range& e) {
40100       {
40101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40102       };
40103     } catch (std::exception& e) {
40104       {
40105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40106       };
40107     } catch (Dali::DaliException e) {
40108       {
40109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40110       };
40111     } catch (...) {
40112       {
40113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40114       };
40115     }
40116   }
40117
40118   jresult = result;
40119   return jresult;
40120 }
40121
40122
40123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40124   void * jresult ;
40125   Dali::CustomActor *result = 0 ;
40126
40127   {
40128     try {
40129       result = (Dali::CustomActor *)new Dali::CustomActor();
40130     } catch (std::out_of_range& e) {
40131       {
40132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40133       };
40134     } catch (std::exception& e) {
40135       {
40136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40137       };
40138     } catch (Dali::DaliException e) {
40139       {
40140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40141       };
40142     } catch (...) {
40143       {
40144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40145       };
40146     }
40147   }
40148
40149   jresult = (void *)result;
40150   return jresult;
40151 }
40152
40153
40154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40155   void * jresult ;
40156   Dali::BaseHandle arg1 ;
40157   Dali::BaseHandle *argp1 ;
40158   Dali::CustomActor result;
40159
40160   argp1 = (Dali::BaseHandle *)jarg1;
40161   if (!argp1) {
40162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40163     return 0;
40164   }
40165   arg1 = *argp1;
40166   {
40167     try {
40168       result = Dali::CustomActor::DownCast(arg1);
40169     } catch (std::out_of_range& e) {
40170       {
40171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40172       };
40173     } catch (std::exception& e) {
40174       {
40175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40176       };
40177     } catch (Dali::DaliException e) {
40178       {
40179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40180       };
40181     } catch (...) {
40182       {
40183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40184       };
40185     }
40186   }
40187
40188   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40189   return jresult;
40190 }
40191
40192
40193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40194   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40195
40196   arg1 = (Dali::CustomActor *)jarg1;
40197   {
40198     try {
40199       delete arg1;
40200     } catch (std::out_of_range& e) {
40201       {
40202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40203       };
40204     } catch (std::exception& e) {
40205       {
40206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40207       };
40208     } catch (Dali::DaliException e) {
40209       {
40210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40211       };
40212     } catch (...) {
40213       {
40214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40215       };
40216     }
40217   }
40218
40219 }
40220
40221
40222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40223   void * jresult ;
40224   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40225   Dali::CustomActorImpl *result = 0 ;
40226
40227   arg1 = (Dali::CustomActor *)jarg1;
40228   {
40229     try {
40230       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40231     } catch (std::out_of_range& e) {
40232       {
40233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40234       };
40235     } catch (std::exception& e) {
40236       {
40237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40238       };
40239     } catch (Dali::DaliException e) {
40240       {
40241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40242       };
40243     } catch (...) {
40244       {
40245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40246       };
40247     }
40248   }
40249
40250   jresult = (void *)result;
40251   return jresult;
40252 }
40253
40254
40255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40256   void * jresult ;
40257   Dali::CustomActorImpl *arg1 = 0 ;
40258   Dali::CustomActor *result = 0 ;
40259
40260   arg1 = (Dali::CustomActorImpl *)jarg1;
40261   if (!arg1) {
40262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40263     return 0;
40264   }
40265   {
40266     try {
40267       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40268     } catch (std::out_of_range& e) {
40269       {
40270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40271       };
40272     } catch (std::exception& e) {
40273       {
40274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40275       };
40276     } catch (Dali::DaliException e) {
40277       {
40278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40279       };
40280     } catch (...) {
40281       {
40282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40283       };
40284     }
40285   }
40286
40287   jresult = (void *)result;
40288   return jresult;
40289 }
40290
40291
40292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40293   void * jresult ;
40294   Dali::CustomActor *arg1 = 0 ;
40295   Dali::CustomActor *result = 0 ;
40296
40297   arg1 = (Dali::CustomActor *)jarg1;
40298   if (!arg1) {
40299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40300     return 0;
40301   }
40302   {
40303     try {
40304       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40305     } catch (std::out_of_range& e) {
40306       {
40307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40308       };
40309     } catch (std::exception& e) {
40310       {
40311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40312       };
40313     } catch (Dali::DaliException e) {
40314       {
40315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40316       };
40317     } catch (...) {
40318       {
40319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40320       };
40321     }
40322   }
40323
40324   jresult = (void *)result;
40325   return jresult;
40326 }
40327
40328
40329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40330   void * jresult ;
40331   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40332   Dali::CustomActor *arg2 = 0 ;
40333   Dali::CustomActor *result = 0 ;
40334
40335   arg1 = (Dali::CustomActor *)jarg1;
40336   arg2 = (Dali::CustomActor *)jarg2;
40337   if (!arg2) {
40338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40339     return 0;
40340   }
40341   {
40342     try {
40343       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40344     } catch (std::out_of_range& e) {
40345       {
40346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40347       };
40348     } catch (std::exception& e) {
40349       {
40350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40351       };
40352     } catch (Dali::DaliException e) {
40353       {
40354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40355       };
40356     } catch (...) {
40357       {
40358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40359       };
40360     }
40361   }
40362
40363   jresult = (void *)result;
40364   return jresult;
40365 }
40366
40367
40368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40369   int jresult ;
40370   int result;
40371
40372   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40373   jresult = (int)result;
40374   return jresult;
40375 }
40376
40377
40378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40379   int jresult ;
40380   int result;
40381
40382   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40383   jresult = (int)result;
40384   return jresult;
40385 }
40386
40387
40388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40389   int jresult ;
40390   int result;
40391
40392   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40393   jresult = (int)result;
40394   return jresult;
40395 }
40396
40397
40398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40399   int jresult ;
40400   int result;
40401
40402   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40403   jresult = (int)result;
40404   return jresult;
40405 }
40406
40407
40408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40409   int jresult ;
40410   int result;
40411
40412   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40413   jresult = (int)result;
40414   return jresult;
40415 }
40416
40417
40418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40419   int jresult ;
40420   int result;
40421
40422   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40423   jresult = (int)result;
40424   return jresult;
40425 }
40426
40427
40428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40429   int jresult ;
40430   int result;
40431
40432   result = (int)Dali::PanGestureDetector::Property::PANNING;
40433   jresult = (int)result;
40434   return jresult;
40435 }
40436
40437
40438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40439   void * jresult ;
40440   Dali::PanGestureDetector::Property *result = 0 ;
40441
40442   {
40443     try {
40444       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40445     } catch (std::out_of_range& e) {
40446       {
40447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40448       };
40449     } catch (std::exception& e) {
40450       {
40451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40452       };
40453     } catch (Dali::DaliException e) {
40454       {
40455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40456       };
40457     } catch (...) {
40458       {
40459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40460       };
40461     }
40462   }
40463
40464   jresult = (void *)result;
40465   return jresult;
40466 }
40467
40468
40469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40470   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40471
40472   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40473   {
40474     try {
40475       delete arg1;
40476     } catch (std::out_of_range& e) {
40477       {
40478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40479       };
40480     } catch (std::exception& e) {
40481       {
40482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40483       };
40484     } catch (Dali::DaliException e) {
40485       {
40486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40487       };
40488     } catch (...) {
40489       {
40490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40491       };
40492     }
40493   }
40494
40495 }
40496
40497
40498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40499   void * jresult ;
40500   Dali::Radian *result = 0 ;
40501
40502   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40503   jresult = (void *)result;
40504   return jresult;
40505 }
40506
40507
40508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40509   void * jresult ;
40510   Dali::Radian *result = 0 ;
40511
40512   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40513   jresult = (void *)result;
40514   return jresult;
40515 }
40516
40517
40518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40519   void * jresult ;
40520   Dali::Radian *result = 0 ;
40521
40522   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40523   jresult = (void *)result;
40524   return jresult;
40525 }
40526
40527
40528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40529   void * jresult ;
40530   Dali::Radian *result = 0 ;
40531
40532   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40533   jresult = (void *)result;
40534   return jresult;
40535 }
40536
40537
40538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40539   void * jresult ;
40540   Dali::Radian *result = 0 ;
40541
40542   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40543   jresult = (void *)result;
40544   return jresult;
40545 }
40546
40547
40548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40549   void * jresult ;
40550   Dali::Radian *result = 0 ;
40551
40552   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40553   jresult = (void *)result;
40554   return jresult;
40555 }
40556
40557
40558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40559   void * jresult ;
40560   Dali::Radian *result = 0 ;
40561
40562   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40563   jresult = (void *)result;
40564   return jresult;
40565 }
40566
40567
40568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40569   void * jresult ;
40570   Dali::PanGestureDetector *result = 0 ;
40571
40572   {
40573     try {
40574       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40575     } catch (std::out_of_range& e) {
40576       {
40577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40578       };
40579     } catch (std::exception& e) {
40580       {
40581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40582       };
40583     } catch (Dali::DaliException e) {
40584       {
40585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40586       };
40587     } catch (...) {
40588       {
40589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40590       };
40591     }
40592   }
40593
40594   jresult = (void *)result;
40595   return jresult;
40596 }
40597
40598
40599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40600   void * jresult ;
40601   Dali::PanGestureDetector result;
40602
40603   {
40604     try {
40605       result = Dali::PanGestureDetector::New();
40606     } catch (std::out_of_range& e) {
40607       {
40608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40609       };
40610     } catch (std::exception& e) {
40611       {
40612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40613       };
40614     } catch (Dali::DaliException e) {
40615       {
40616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40617       };
40618     } catch (...) {
40619       {
40620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40621       };
40622     }
40623   }
40624
40625   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40626   return jresult;
40627 }
40628
40629
40630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40631   void * jresult ;
40632   Dali::BaseHandle arg1 ;
40633   Dali::BaseHandle *argp1 ;
40634   Dali::PanGestureDetector result;
40635
40636   argp1 = (Dali::BaseHandle *)jarg1;
40637   if (!argp1) {
40638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40639     return 0;
40640   }
40641   arg1 = *argp1;
40642   {
40643     try {
40644       result = Dali::PanGestureDetector::DownCast(arg1);
40645     } catch (std::out_of_range& e) {
40646       {
40647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40648       };
40649     } catch (std::exception& e) {
40650       {
40651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40652       };
40653     } catch (Dali::DaliException e) {
40654       {
40655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40656       };
40657     } catch (...) {
40658       {
40659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40660       };
40661     }
40662   }
40663
40664   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40665   return jresult;
40666 }
40667
40668
40669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40670   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40671
40672   arg1 = (Dali::PanGestureDetector *)jarg1;
40673   {
40674     try {
40675       delete arg1;
40676     } catch (std::out_of_range& e) {
40677       {
40678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40679       };
40680     } catch (std::exception& e) {
40681       {
40682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40683       };
40684     } catch (Dali::DaliException e) {
40685       {
40686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40687       };
40688     } catch (...) {
40689       {
40690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40691       };
40692     }
40693   }
40694
40695 }
40696
40697
40698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40699   void * jresult ;
40700   Dali::PanGestureDetector *arg1 = 0 ;
40701   Dali::PanGestureDetector *result = 0 ;
40702
40703   arg1 = (Dali::PanGestureDetector *)jarg1;
40704   if (!arg1) {
40705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40706     return 0;
40707   }
40708   {
40709     try {
40710       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40711     } catch (std::out_of_range& e) {
40712       {
40713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40714       };
40715     } catch (std::exception& e) {
40716       {
40717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40718       };
40719     } catch (Dali::DaliException e) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40722       };
40723     } catch (...) {
40724       {
40725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40726       };
40727     }
40728   }
40729
40730   jresult = (void *)result;
40731   return jresult;
40732 }
40733
40734
40735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40736   void * jresult ;
40737   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40738   Dali::PanGestureDetector *arg2 = 0 ;
40739   Dali::PanGestureDetector *result = 0 ;
40740
40741   arg1 = (Dali::PanGestureDetector *)jarg1;
40742   arg2 = (Dali::PanGestureDetector *)jarg2;
40743   if (!arg2) {
40744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40745     return 0;
40746   }
40747   {
40748     try {
40749       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40750     } catch (std::out_of_range& e) {
40751       {
40752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40753       };
40754     } catch (std::exception& e) {
40755       {
40756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40757       };
40758     } catch (Dali::DaliException e) {
40759       {
40760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40761       };
40762     } catch (...) {
40763       {
40764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40765       };
40766     }
40767   }
40768
40769   jresult = (void *)result;
40770   return jresult;
40771 }
40772
40773
40774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40775   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40776   unsigned int arg2 ;
40777
40778   arg1 = (Dali::PanGestureDetector *)jarg1;
40779   arg2 = (unsigned int)jarg2;
40780   {
40781     try {
40782       (arg1)->SetMinimumTouchesRequired(arg2);
40783     } catch (std::out_of_range& e) {
40784       {
40785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40786       };
40787     } catch (std::exception& e) {
40788       {
40789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40790       };
40791     } catch (Dali::DaliException e) {
40792       {
40793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40794       };
40795     } catch (...) {
40796       {
40797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40798       };
40799     }
40800   }
40801
40802 }
40803
40804
40805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40806   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40807   unsigned int arg2 ;
40808
40809   arg1 = (Dali::PanGestureDetector *)jarg1;
40810   arg2 = (unsigned int)jarg2;
40811   {
40812     try {
40813       (arg1)->SetMaximumTouchesRequired(arg2);
40814     } catch (std::out_of_range& e) {
40815       {
40816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40817       };
40818     } catch (std::exception& e) {
40819       {
40820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40821       };
40822     } catch (Dali::DaliException e) {
40823       {
40824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40825       };
40826     } catch (...) {
40827       {
40828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40829       };
40830     }
40831   }
40832
40833 }
40834
40835
40836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40837   unsigned int jresult ;
40838   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40839   unsigned int result;
40840
40841   arg1 = (Dali::PanGestureDetector *)jarg1;
40842   {
40843     try {
40844       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40845     } catch (std::out_of_range& e) {
40846       {
40847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40848       };
40849     } catch (std::exception& e) {
40850       {
40851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40852       };
40853     } catch (Dali::DaliException e) {
40854       {
40855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40856       };
40857     } catch (...) {
40858       {
40859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40860       };
40861     }
40862   }
40863
40864   jresult = result;
40865   return jresult;
40866 }
40867
40868
40869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40870   unsigned int jresult ;
40871   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40872   unsigned int result;
40873
40874   arg1 = (Dali::PanGestureDetector *)jarg1;
40875   {
40876     try {
40877       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40878     } catch (std::out_of_range& e) {
40879       {
40880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40881       };
40882     } catch (std::exception& e) {
40883       {
40884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40885       };
40886     } catch (Dali::DaliException e) {
40887       {
40888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40889       };
40890     } catch (...) {
40891       {
40892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40893       };
40894     }
40895   }
40896
40897   jresult = result;
40898   return jresult;
40899 }
40900
40901
40902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40903   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40904   Dali::Radian arg2 ;
40905   Dali::Radian arg3 ;
40906   Dali::Radian *argp2 ;
40907   Dali::Radian *argp3 ;
40908
40909   arg1 = (Dali::PanGestureDetector *)jarg1;
40910   argp2 = (Dali::Radian *)jarg2;
40911   if (!argp2) {
40912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40913     return ;
40914   }
40915   arg2 = *argp2;
40916   argp3 = (Dali::Radian *)jarg3;
40917   if (!argp3) {
40918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40919     return ;
40920   }
40921   arg3 = *argp3;
40922   {
40923     try {
40924       (arg1)->AddAngle(arg2,arg3);
40925     } catch (std::out_of_range& e) {
40926       {
40927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40928       };
40929     } catch (std::exception& e) {
40930       {
40931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40932       };
40933     } catch (Dali::DaliException e) {
40934       {
40935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40936       };
40937     } catch (...) {
40938       {
40939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40940       };
40941     }
40942   }
40943
40944 }
40945
40946
40947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40948   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40949   Dali::Radian arg2 ;
40950   Dali::Radian *argp2 ;
40951
40952   arg1 = (Dali::PanGestureDetector *)jarg1;
40953   argp2 = (Dali::Radian *)jarg2;
40954   if (!argp2) {
40955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40956     return ;
40957   }
40958   arg2 = *argp2;
40959   {
40960     try {
40961       (arg1)->AddAngle(arg2);
40962     } catch (std::out_of_range& e) {
40963       {
40964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40965       };
40966     } catch (std::exception& e) {
40967       {
40968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40969       };
40970     } catch (Dali::DaliException e) {
40971       {
40972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40973       };
40974     } catch (...) {
40975       {
40976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40977       };
40978     }
40979   }
40980
40981 }
40982
40983
40984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40985   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40986   Dali::Radian arg2 ;
40987   Dali::Radian arg3 ;
40988   Dali::Radian *argp2 ;
40989   Dali::Radian *argp3 ;
40990
40991   arg1 = (Dali::PanGestureDetector *)jarg1;
40992   argp2 = (Dali::Radian *)jarg2;
40993   if (!argp2) {
40994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40995     return ;
40996   }
40997   arg2 = *argp2;
40998   argp3 = (Dali::Radian *)jarg3;
40999   if (!argp3) {
41000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41001     return ;
41002   }
41003   arg3 = *argp3;
41004   {
41005     try {
41006       (arg1)->AddDirection(arg2,arg3);
41007     } catch (std::out_of_range& e) {
41008       {
41009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41010       };
41011     } catch (std::exception& e) {
41012       {
41013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41014       };
41015     } catch (Dali::DaliException e) {
41016       {
41017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41018       };
41019     } catch (...) {
41020       {
41021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41022       };
41023     }
41024   }
41025
41026 }
41027
41028
41029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41030   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41031   Dali::Radian arg2 ;
41032   Dali::Radian *argp2 ;
41033
41034   arg1 = (Dali::PanGestureDetector *)jarg1;
41035   argp2 = (Dali::Radian *)jarg2;
41036   if (!argp2) {
41037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41038     return ;
41039   }
41040   arg2 = *argp2;
41041   {
41042     try {
41043       (arg1)->AddDirection(arg2);
41044     } catch (std::out_of_range& e) {
41045       {
41046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41047       };
41048     } catch (std::exception& e) {
41049       {
41050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41051       };
41052     } catch (Dali::DaliException e) {
41053       {
41054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41055       };
41056     } catch (...) {
41057       {
41058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41059       };
41060     }
41061   }
41062
41063 }
41064
41065
41066 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41067   unsigned long jresult ;
41068   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41069   size_t result;
41070
41071   arg1 = (Dali::PanGestureDetector *)jarg1;
41072   {
41073     try {
41074       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41075     } catch (std::out_of_range& e) {
41076       {
41077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41078       };
41079     } catch (std::exception& e) {
41080       {
41081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41082       };
41083     } catch (Dali::DaliException e) {
41084       {
41085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41086       };
41087     } catch (...) {
41088       {
41089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41090       };
41091     }
41092   }
41093
41094   jresult = (unsigned long)result;
41095   return jresult;
41096 }
41097
41098
41099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41100   void * jresult ;
41101   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41102   size_t arg2 ;
41103   Dali::PanGestureDetector::AngleThresholdPair result;
41104
41105   arg1 = (Dali::PanGestureDetector *)jarg1;
41106   arg2 = (size_t)jarg2;
41107   {
41108     try {
41109       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41110     } catch (std::out_of_range& e) {
41111       {
41112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41113       };
41114     } catch (std::exception& e) {
41115       {
41116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41117       };
41118     } catch (Dali::DaliException e) {
41119       {
41120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41121       };
41122     } catch (...) {
41123       {
41124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41125       };
41126     }
41127   }
41128
41129   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41130   return jresult;
41131 }
41132
41133
41134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41135   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41136
41137   arg1 = (Dali::PanGestureDetector *)jarg1;
41138   {
41139     try {
41140       (arg1)->ClearAngles();
41141     } catch (std::out_of_range& e) {
41142       {
41143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41144       };
41145     } catch (std::exception& e) {
41146       {
41147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41148       };
41149     } catch (Dali::DaliException e) {
41150       {
41151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41152       };
41153     } catch (...) {
41154       {
41155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41156       };
41157     }
41158   }
41159
41160 }
41161
41162
41163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41164   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41165   Dali::Radian arg2 ;
41166   Dali::Radian *argp2 ;
41167
41168   arg1 = (Dali::PanGestureDetector *)jarg1;
41169   argp2 = (Dali::Radian *)jarg2;
41170   if (!argp2) {
41171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41172     return ;
41173   }
41174   arg2 = *argp2;
41175   {
41176     try {
41177       (arg1)->RemoveAngle(arg2);
41178     } catch (std::out_of_range& e) {
41179       {
41180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41181       };
41182     } catch (std::exception& e) {
41183       {
41184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41185       };
41186     } catch (Dali::DaliException e) {
41187       {
41188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41189       };
41190     } catch (...) {
41191       {
41192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41193       };
41194     }
41195   }
41196
41197 }
41198
41199
41200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41201   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41202   Dali::Radian arg2 ;
41203   Dali::Radian *argp2 ;
41204
41205   arg1 = (Dali::PanGestureDetector *)jarg1;
41206   argp2 = (Dali::Radian *)jarg2;
41207   if (!argp2) {
41208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41209     return ;
41210   }
41211   arg2 = *argp2;
41212   {
41213     try {
41214       (arg1)->RemoveDirection(arg2);
41215     } catch (std::out_of_range& e) {
41216       {
41217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41218       };
41219     } catch (std::exception& e) {
41220       {
41221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41222       };
41223     } catch (Dali::DaliException e) {
41224       {
41225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41226       };
41227     } catch (...) {
41228       {
41229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41230       };
41231     }
41232   }
41233
41234 }
41235
41236
41237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41238   void * jresult ;
41239   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41240   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41241
41242   arg1 = (Dali::PanGestureDetector *)jarg1;
41243   {
41244     try {
41245       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
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 (Dali::DaliException e) {
41255       {
41256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41257       };
41258     } catch (...) {
41259       {
41260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41261       };
41262     }
41263   }
41264
41265   jresult = (void *)result;
41266   return jresult;
41267 }
41268
41269
41270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41271   Dali::PanGesture *arg1 = 0 ;
41272
41273   arg1 = (Dali::PanGesture *)jarg1;
41274   if (!arg1) {
41275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41276     return ;
41277   }
41278   {
41279     try {
41280       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41281     } catch (std::out_of_range& e) {
41282       {
41283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41284       };
41285     } catch (std::exception& e) {
41286       {
41287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41288       };
41289     } catch (Dali::DaliException e) {
41290       {
41291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41292       };
41293     } catch (...) {
41294       {
41295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41296       };
41297     }
41298   }
41299
41300 }
41301
41302
41303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41304   void * jresult ;
41305   Dali::PanGesture *result = 0 ;
41306
41307   {
41308     try {
41309       result = (Dali::PanGesture *)new Dali::PanGesture();
41310     } catch (std::out_of_range& e) {
41311       {
41312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41313       };
41314     } catch (std::exception& e) {
41315       {
41316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41317       };
41318     } catch (Dali::DaliException e) {
41319       {
41320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41321       };
41322     } catch (...) {
41323       {
41324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41325       };
41326     }
41327   }
41328
41329   jresult = (void *)result;
41330   return jresult;
41331 }
41332
41333
41334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41335   void * jresult ;
41336   Dali::Gesture::State arg1 ;
41337   Dali::PanGesture *result = 0 ;
41338
41339   arg1 = (Dali::Gesture::State)jarg1;
41340   {
41341     try {
41342       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41343     } catch (std::out_of_range& e) {
41344       {
41345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41346       };
41347     } catch (std::exception& e) {
41348       {
41349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41350       };
41351     } catch (Dali::DaliException e) {
41352       {
41353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41354       };
41355     } catch (...) {
41356       {
41357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41358       };
41359     }
41360   }
41361
41362   jresult = (void *)result;
41363   return jresult;
41364 }
41365
41366
41367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41368   void * jresult ;
41369   Dali::PanGesture *arg1 = 0 ;
41370   Dali::PanGesture *result = 0 ;
41371
41372   arg1 = (Dali::PanGesture *)jarg1;
41373   if (!arg1) {
41374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41375     return 0;
41376   }
41377   {
41378     try {
41379       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41380     } catch (std::out_of_range& e) {
41381       {
41382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41383       };
41384     } catch (std::exception& e) {
41385       {
41386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41387       };
41388     } catch (Dali::DaliException e) {
41389       {
41390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41391       };
41392     } catch (...) {
41393       {
41394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41395       };
41396     }
41397   }
41398
41399   jresult = (void *)result;
41400   return jresult;
41401 }
41402
41403
41404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41405   void * jresult ;
41406   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41407   Dali::PanGesture *arg2 = 0 ;
41408   Dali::PanGesture *result = 0 ;
41409
41410   arg1 = (Dali::PanGesture *)jarg1;
41411   arg2 = (Dali::PanGesture *)jarg2;
41412   if (!arg2) {
41413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41414     return 0;
41415   }
41416   {
41417     try {
41418       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41419     } catch (std::out_of_range& e) {
41420       {
41421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41422       };
41423     } catch (std::exception& e) {
41424       {
41425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41426       };
41427     } catch (Dali::DaliException e) {
41428       {
41429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41430       };
41431     } catch (...) {
41432       {
41433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41434       };
41435     }
41436   }
41437
41438   jresult = (void *)result;
41439   return jresult;
41440 }
41441
41442
41443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41444   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41445
41446   arg1 = (Dali::PanGesture *)jarg1;
41447   {
41448     try {
41449       delete arg1;
41450     } catch (std::out_of_range& e) {
41451       {
41452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41453       };
41454     } catch (std::exception& e) {
41455       {
41456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41457       };
41458     } catch (Dali::DaliException e) {
41459       {
41460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41461       };
41462     } catch (...) {
41463       {
41464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41465       };
41466     }
41467   }
41468
41469 }
41470
41471
41472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41473   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41474   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41475
41476   arg1 = (Dali::PanGesture *)jarg1;
41477   arg2 = (Dali::Vector2 *)jarg2;
41478   if (arg1) (arg1)->velocity = *arg2;
41479 }
41480
41481
41482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41483   void * jresult ;
41484   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41485   Dali::Vector2 *result = 0 ;
41486
41487   arg1 = (Dali::PanGesture *)jarg1;
41488   result = (Dali::Vector2 *)& ((arg1)->velocity);
41489   jresult = (void *)result;
41490   return jresult;
41491 }
41492
41493
41494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41495   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41496   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41497
41498   arg1 = (Dali::PanGesture *)jarg1;
41499   arg2 = (Dali::Vector2 *)jarg2;
41500   if (arg1) (arg1)->displacement = *arg2;
41501 }
41502
41503
41504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41505   void * jresult ;
41506   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41507   Dali::Vector2 *result = 0 ;
41508
41509   arg1 = (Dali::PanGesture *)jarg1;
41510   result = (Dali::Vector2 *)& ((arg1)->displacement);
41511   jresult = (void *)result;
41512   return jresult;
41513 }
41514
41515
41516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41517   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41518   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41519
41520   arg1 = (Dali::PanGesture *)jarg1;
41521   arg2 = (Dali::Vector2 *)jarg2;
41522   if (arg1) (arg1)->position = *arg2;
41523 }
41524
41525
41526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41527   void * jresult ;
41528   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41529   Dali::Vector2 *result = 0 ;
41530
41531   arg1 = (Dali::PanGesture *)jarg1;
41532   result = (Dali::Vector2 *)& ((arg1)->position);
41533   jresult = (void *)result;
41534   return jresult;
41535 }
41536
41537
41538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41539   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41540   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41541
41542   arg1 = (Dali::PanGesture *)jarg1;
41543   arg2 = (Dali::Vector2 *)jarg2;
41544   if (arg1) (arg1)->screenVelocity = *arg2;
41545 }
41546
41547
41548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41549   void * jresult ;
41550   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41551   Dali::Vector2 *result = 0 ;
41552
41553   arg1 = (Dali::PanGesture *)jarg1;
41554   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41555   jresult = (void *)result;
41556   return jresult;
41557 }
41558
41559
41560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41561   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41562   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41563
41564   arg1 = (Dali::PanGesture *)jarg1;
41565   arg2 = (Dali::Vector2 *)jarg2;
41566   if (arg1) (arg1)->screenDisplacement = *arg2;
41567 }
41568
41569
41570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41571   void * jresult ;
41572   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41573   Dali::Vector2 *result = 0 ;
41574
41575   arg1 = (Dali::PanGesture *)jarg1;
41576   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41577   jresult = (void *)result;
41578   return jresult;
41579 }
41580
41581
41582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41583   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41584   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41585
41586   arg1 = (Dali::PanGesture *)jarg1;
41587   arg2 = (Dali::Vector2 *)jarg2;
41588   if (arg1) (arg1)->screenPosition = *arg2;
41589 }
41590
41591
41592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41593   void * jresult ;
41594   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41595   Dali::Vector2 *result = 0 ;
41596
41597   arg1 = (Dali::PanGesture *)jarg1;
41598   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41599   jresult = (void *)result;
41600   return jresult;
41601 }
41602
41603
41604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41605   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41606   unsigned int arg2 ;
41607
41608   arg1 = (Dali::PanGesture *)jarg1;
41609   arg2 = (unsigned int)jarg2;
41610   if (arg1) (arg1)->numberOfTouches = arg2;
41611 }
41612
41613
41614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41615   unsigned int jresult ;
41616   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41617   unsigned int result;
41618
41619   arg1 = (Dali::PanGesture *)jarg1;
41620   result = (unsigned int) ((arg1)->numberOfTouches);
41621   jresult = result;
41622   return jresult;
41623 }
41624
41625
41626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41627   float jresult ;
41628   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41629   float result;
41630
41631   arg1 = (Dali::PanGesture *)jarg1;
41632   {
41633     try {
41634       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41635     } catch (std::out_of_range& e) {
41636       {
41637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41638       };
41639     } catch (std::exception& e) {
41640       {
41641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41642       };
41643     } catch (Dali::DaliException e) {
41644       {
41645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41646       };
41647     } catch (...) {
41648       {
41649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41650       };
41651     }
41652   }
41653
41654   jresult = result;
41655   return jresult;
41656 }
41657
41658
41659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41660   float jresult ;
41661   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41662   float result;
41663
41664   arg1 = (Dali::PanGesture *)jarg1;
41665   {
41666     try {
41667       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41668     } catch (std::out_of_range& e) {
41669       {
41670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41671       };
41672     } catch (std::exception& e) {
41673       {
41674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41675       };
41676     } catch (Dali::DaliException e) {
41677       {
41678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41679       };
41680     } catch (...) {
41681       {
41682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41683       };
41684     }
41685   }
41686
41687   jresult = result;
41688   return jresult;
41689 }
41690
41691
41692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41693   float jresult ;
41694   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41695   float result;
41696
41697   arg1 = (Dali::PanGesture *)jarg1;
41698   {
41699     try {
41700       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41701     } catch (std::out_of_range& e) {
41702       {
41703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41704       };
41705     } catch (std::exception& e) {
41706       {
41707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41708       };
41709     } catch (Dali::DaliException e) {
41710       {
41711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41712       };
41713     } catch (...) {
41714       {
41715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41716       };
41717     }
41718   }
41719
41720   jresult = result;
41721   return jresult;
41722 }
41723
41724
41725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41726   float jresult ;
41727   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41728   float result;
41729
41730   arg1 = (Dali::PanGesture *)jarg1;
41731   {
41732     try {
41733       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41734     } catch (std::out_of_range& e) {
41735       {
41736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41737       };
41738     } catch (std::exception& e) {
41739       {
41740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41741       };
41742     } catch (Dali::DaliException e) {
41743       {
41744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41745       };
41746     } catch (...) {
41747       {
41748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41749       };
41750     }
41751   }
41752
41753   jresult = result;
41754   return jresult;
41755 }
41756
41757
41758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41759   void * jresult ;
41760   Dali::PinchGestureDetector *result = 0 ;
41761
41762   {
41763     try {
41764       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41765     } catch (std::out_of_range& e) {
41766       {
41767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41768       };
41769     } catch (std::exception& e) {
41770       {
41771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41772       };
41773     } catch (Dali::DaliException e) {
41774       {
41775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41776       };
41777     } catch (...) {
41778       {
41779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41780       };
41781     }
41782   }
41783
41784   jresult = (void *)result;
41785   return jresult;
41786 }
41787
41788
41789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41790   void * jresult ;
41791   Dali::PinchGestureDetector result;
41792
41793   {
41794     try {
41795       result = Dali::PinchGestureDetector::New();
41796     } catch (std::out_of_range& e) {
41797       {
41798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41799       };
41800     } catch (std::exception& e) {
41801       {
41802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41803       };
41804     } catch (Dali::DaliException e) {
41805       {
41806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41807       };
41808     } catch (...) {
41809       {
41810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41811       };
41812     }
41813   }
41814
41815   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41816   return jresult;
41817 }
41818
41819
41820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41821   void * jresult ;
41822   Dali::BaseHandle arg1 ;
41823   Dali::BaseHandle *argp1 ;
41824   Dali::PinchGestureDetector result;
41825
41826   argp1 = (Dali::BaseHandle *)jarg1;
41827   if (!argp1) {
41828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41829     return 0;
41830   }
41831   arg1 = *argp1;
41832   {
41833     try {
41834       result = Dali::PinchGestureDetector::DownCast(arg1);
41835     } catch (std::out_of_range& e) {
41836       {
41837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41838       };
41839     } catch (std::exception& e) {
41840       {
41841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41842       };
41843     } catch (Dali::DaliException e) {
41844       {
41845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41846       };
41847     } catch (...) {
41848       {
41849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41850       };
41851     }
41852   }
41853
41854   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41855   return jresult;
41856 }
41857
41858
41859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41860   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41861
41862   arg1 = (Dali::PinchGestureDetector *)jarg1;
41863   {
41864     try {
41865       delete arg1;
41866     } catch (std::out_of_range& e) {
41867       {
41868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41869       };
41870     } catch (std::exception& e) {
41871       {
41872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41873       };
41874     } catch (Dali::DaliException e) {
41875       {
41876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41877       };
41878     } catch (...) {
41879       {
41880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41881       };
41882     }
41883   }
41884
41885 }
41886
41887
41888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41889   void * jresult ;
41890   Dali::PinchGestureDetector *arg1 = 0 ;
41891   Dali::PinchGestureDetector *result = 0 ;
41892
41893   arg1 = (Dali::PinchGestureDetector *)jarg1;
41894   if (!arg1) {
41895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41896     return 0;
41897   }
41898   {
41899     try {
41900       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41901     } catch (std::out_of_range& e) {
41902       {
41903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41904       };
41905     } catch (std::exception& e) {
41906       {
41907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41908       };
41909     } catch (Dali::DaliException e) {
41910       {
41911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41912       };
41913     } catch (...) {
41914       {
41915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41916       };
41917     }
41918   }
41919
41920   jresult = (void *)result;
41921   return jresult;
41922 }
41923
41924
41925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41926   void * jresult ;
41927   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41928   Dali::PinchGestureDetector *arg2 = 0 ;
41929   Dali::PinchGestureDetector *result = 0 ;
41930
41931   arg1 = (Dali::PinchGestureDetector *)jarg1;
41932   arg2 = (Dali::PinchGestureDetector *)jarg2;
41933   if (!arg2) {
41934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41935     return 0;
41936   }
41937   {
41938     try {
41939       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
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 (Dali::DaliException e) {
41949       {
41950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41951       };
41952     } catch (...) {
41953       {
41954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41955       };
41956     }
41957   }
41958
41959   jresult = (void *)result;
41960   return jresult;
41961 }
41962
41963
41964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41965   void * jresult ;
41966   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41967   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41968
41969   arg1 = (Dali::PinchGestureDetector *)jarg1;
41970   {
41971     try {
41972       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41973     } catch (std::out_of_range& e) {
41974       {
41975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41976       };
41977     } catch (std::exception& e) {
41978       {
41979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41980       };
41981     } catch (Dali::DaliException e) {
41982       {
41983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41984       };
41985     } catch (...) {
41986       {
41987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41988       };
41989     }
41990   }
41991
41992   jresult = (void *)result;
41993   return jresult;
41994 }
41995
41996
41997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41998   void * jresult ;
41999   Dali::Gesture::State arg1 ;
42000   Dali::PinchGesture *result = 0 ;
42001
42002   arg1 = (Dali::Gesture::State)jarg1;
42003   {
42004     try {
42005       result = (Dali::PinchGesture *)new Dali::PinchGesture(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 (Dali::DaliException e) {
42015       {
42016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42017       };
42018     } catch (...) {
42019       {
42020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42021       };
42022     }
42023   }
42024
42025   jresult = (void *)result;
42026   return jresult;
42027 }
42028
42029
42030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42031   void * jresult ;
42032   Dali::PinchGesture *arg1 = 0 ;
42033   Dali::PinchGesture *result = 0 ;
42034
42035   arg1 = (Dali::PinchGesture *)jarg1;
42036   if (!arg1) {
42037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42038     return 0;
42039   }
42040   {
42041     try {
42042       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42043     } catch (std::out_of_range& e) {
42044       {
42045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42046       };
42047     } catch (std::exception& e) {
42048       {
42049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42050       };
42051     } catch (Dali::DaliException e) {
42052       {
42053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42054       };
42055     } catch (...) {
42056       {
42057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42058       };
42059     }
42060   }
42061
42062   jresult = (void *)result;
42063   return jresult;
42064 }
42065
42066
42067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42068   void * jresult ;
42069   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42070   Dali::PinchGesture *arg2 = 0 ;
42071   Dali::PinchGesture *result = 0 ;
42072
42073   arg1 = (Dali::PinchGesture *)jarg1;
42074   arg2 = (Dali::PinchGesture *)jarg2;
42075   if (!arg2) {
42076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42077     return 0;
42078   }
42079   {
42080     try {
42081       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42082     } catch (std::out_of_range& e) {
42083       {
42084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42085       };
42086     } catch (std::exception& e) {
42087       {
42088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42089       };
42090     } catch (Dali::DaliException e) {
42091       {
42092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42093       };
42094     } catch (...) {
42095       {
42096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42097       };
42098     }
42099   }
42100
42101   jresult = (void *)result;
42102   return jresult;
42103 }
42104
42105
42106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42107   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42108
42109   arg1 = (Dali::PinchGesture *)jarg1;
42110   {
42111     try {
42112       delete arg1;
42113     } catch (std::out_of_range& e) {
42114       {
42115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42116       };
42117     } catch (std::exception& e) {
42118       {
42119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42120       };
42121     } catch (Dali::DaliException e) {
42122       {
42123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42124       };
42125     } catch (...) {
42126       {
42127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42128       };
42129     }
42130   }
42131
42132 }
42133
42134
42135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42136   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42137   float arg2 ;
42138
42139   arg1 = (Dali::PinchGesture *)jarg1;
42140   arg2 = (float)jarg2;
42141   if (arg1) (arg1)->scale = arg2;
42142 }
42143
42144
42145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42146   float jresult ;
42147   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42148   float result;
42149
42150   arg1 = (Dali::PinchGesture *)jarg1;
42151   result = (float) ((arg1)->scale);
42152   jresult = result;
42153   return jresult;
42154 }
42155
42156
42157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42158   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42159   float arg2 ;
42160
42161   arg1 = (Dali::PinchGesture *)jarg1;
42162   arg2 = (float)jarg2;
42163   if (arg1) (arg1)->speed = arg2;
42164 }
42165
42166
42167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42168   float jresult ;
42169   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42170   float result;
42171
42172   arg1 = (Dali::PinchGesture *)jarg1;
42173   result = (float) ((arg1)->speed);
42174   jresult = result;
42175   return jresult;
42176 }
42177
42178
42179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42180   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42181   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42182
42183   arg1 = (Dali::PinchGesture *)jarg1;
42184   arg2 = (Dali::Vector2 *)jarg2;
42185   if (arg1) (arg1)->screenCenterPoint = *arg2;
42186 }
42187
42188
42189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42190   void * jresult ;
42191   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42192   Dali::Vector2 *result = 0 ;
42193
42194   arg1 = (Dali::PinchGesture *)jarg1;
42195   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42196   jresult = (void *)result;
42197   return jresult;
42198 }
42199
42200
42201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42202   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42203   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42204
42205   arg1 = (Dali::PinchGesture *)jarg1;
42206   arg2 = (Dali::Vector2 *)jarg2;
42207   if (arg1) (arg1)->localCenterPoint = *arg2;
42208 }
42209
42210
42211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42212   void * jresult ;
42213   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42214   Dali::Vector2 *result = 0 ;
42215
42216   arg1 = (Dali::PinchGesture *)jarg1;
42217   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42218   jresult = (void *)result;
42219   return jresult;
42220 }
42221
42222
42223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42224   void * jresult ;
42225   Dali::TapGestureDetector *result = 0 ;
42226
42227   {
42228     try {
42229       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42230     } catch (std::out_of_range& e) {
42231       {
42232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42233       };
42234     } catch (std::exception& e) {
42235       {
42236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42237       };
42238     } catch (Dali::DaliException e) {
42239       {
42240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42241       };
42242     } catch (...) {
42243       {
42244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42245       };
42246     }
42247   }
42248
42249   jresult = (void *)result;
42250   return jresult;
42251 }
42252
42253
42254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42255   void * jresult ;
42256   Dali::TapGestureDetector result;
42257
42258   {
42259     try {
42260       result = Dali::TapGestureDetector::New();
42261     } catch (std::out_of_range& e) {
42262       {
42263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42264       };
42265     } catch (std::exception& e) {
42266       {
42267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42268       };
42269     } catch (Dali::DaliException e) {
42270       {
42271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42272       };
42273     } catch (...) {
42274       {
42275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42276       };
42277     }
42278   }
42279
42280   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42281   return jresult;
42282 }
42283
42284
42285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42286   void * jresult ;
42287   unsigned int arg1 ;
42288   Dali::TapGestureDetector result;
42289
42290   arg1 = (unsigned int)jarg1;
42291   {
42292     try {
42293       result = Dali::TapGestureDetector::New(arg1);
42294     } catch (std::out_of_range& e) {
42295       {
42296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42297       };
42298     } catch (std::exception& e) {
42299       {
42300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42301       };
42302     } catch (Dali::DaliException e) {
42303       {
42304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42305       };
42306     } catch (...) {
42307       {
42308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42309       };
42310     }
42311   }
42312
42313   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42314   return jresult;
42315 }
42316
42317
42318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42319   void * jresult ;
42320   Dali::BaseHandle arg1 ;
42321   Dali::BaseHandle *argp1 ;
42322   Dali::TapGestureDetector result;
42323
42324   argp1 = (Dali::BaseHandle *)jarg1;
42325   if (!argp1) {
42326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42327     return 0;
42328   }
42329   arg1 = *argp1;
42330   {
42331     try {
42332       result = Dali::TapGestureDetector::DownCast(arg1);
42333     } catch (std::out_of_range& e) {
42334       {
42335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42336       };
42337     } catch (std::exception& e) {
42338       {
42339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42340       };
42341     } catch (Dali::DaliException e) {
42342       {
42343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42344       };
42345     } catch (...) {
42346       {
42347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42348       };
42349     }
42350   }
42351
42352   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42353   return jresult;
42354 }
42355
42356
42357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42358   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42359
42360   arg1 = (Dali::TapGestureDetector *)jarg1;
42361   {
42362     try {
42363       delete arg1;
42364     } catch (std::out_of_range& e) {
42365       {
42366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42367       };
42368     } catch (std::exception& e) {
42369       {
42370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42371       };
42372     } catch (Dali::DaliException e) {
42373       {
42374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42375       };
42376     } catch (...) {
42377       {
42378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42379       };
42380     }
42381   }
42382
42383 }
42384
42385
42386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42387   void * jresult ;
42388   Dali::TapGestureDetector *arg1 = 0 ;
42389   Dali::TapGestureDetector *result = 0 ;
42390
42391   arg1 = (Dali::TapGestureDetector *)jarg1;
42392   if (!arg1) {
42393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42394     return 0;
42395   }
42396   {
42397     try {
42398       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42399     } catch (std::out_of_range& e) {
42400       {
42401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42402       };
42403     } catch (std::exception& e) {
42404       {
42405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42406       };
42407     } catch (Dali::DaliException e) {
42408       {
42409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42410       };
42411     } catch (...) {
42412       {
42413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42414       };
42415     }
42416   }
42417
42418   jresult = (void *)result;
42419   return jresult;
42420 }
42421
42422
42423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42424   void * jresult ;
42425   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42426   Dali::TapGestureDetector *arg2 = 0 ;
42427   Dali::TapGestureDetector *result = 0 ;
42428
42429   arg1 = (Dali::TapGestureDetector *)jarg1;
42430   arg2 = (Dali::TapGestureDetector *)jarg2;
42431   if (!arg2) {
42432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42433     return 0;
42434   }
42435   {
42436     try {
42437       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42438     } catch (std::out_of_range& e) {
42439       {
42440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42441       };
42442     } catch (std::exception& e) {
42443       {
42444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42445       };
42446     } catch (Dali::DaliException e) {
42447       {
42448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42449       };
42450     } catch (...) {
42451       {
42452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42453       };
42454     }
42455   }
42456
42457   jresult = (void *)result;
42458   return jresult;
42459 }
42460
42461
42462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42463   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42464   unsigned int arg2 ;
42465
42466   arg1 = (Dali::TapGestureDetector *)jarg1;
42467   arg2 = (unsigned int)jarg2;
42468   {
42469     try {
42470       (arg1)->SetMinimumTapsRequired(arg2);
42471     } catch (std::out_of_range& e) {
42472       {
42473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42474       };
42475     } catch (std::exception& e) {
42476       {
42477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42478       };
42479     } catch (Dali::DaliException e) {
42480       {
42481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42482       };
42483     } catch (...) {
42484       {
42485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42486       };
42487     }
42488   }
42489
42490 }
42491
42492
42493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42494   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42495   unsigned int arg2 ;
42496
42497   arg1 = (Dali::TapGestureDetector *)jarg1;
42498   arg2 = (unsigned int)jarg2;
42499   {
42500     try {
42501       (arg1)->SetMaximumTapsRequired(arg2);
42502     } catch (std::out_of_range& e) {
42503       {
42504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42505       };
42506     } catch (std::exception& e) {
42507       {
42508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42509       };
42510     } catch (Dali::DaliException e) {
42511       {
42512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42513       };
42514     } catch (...) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42517       };
42518     }
42519   }
42520
42521 }
42522
42523
42524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42525   unsigned int jresult ;
42526   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42527   unsigned int result;
42528
42529   arg1 = (Dali::TapGestureDetector *)jarg1;
42530   {
42531     try {
42532       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42533     } catch (std::out_of_range& e) {
42534       {
42535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42536       };
42537     } catch (std::exception& e) {
42538       {
42539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42540       };
42541     } catch (Dali::DaliException e) {
42542       {
42543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42544       };
42545     } catch (...) {
42546       {
42547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42548       };
42549     }
42550   }
42551
42552   jresult = result;
42553   return jresult;
42554 }
42555
42556
42557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42558   unsigned int jresult ;
42559   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42560   unsigned int result;
42561
42562   arg1 = (Dali::TapGestureDetector *)jarg1;
42563   {
42564     try {
42565       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42566     } catch (std::out_of_range& e) {
42567       {
42568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42569       };
42570     } catch (std::exception& e) {
42571       {
42572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42573       };
42574     } catch (Dali::DaliException e) {
42575       {
42576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42577       };
42578     } catch (...) {
42579       {
42580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42581       };
42582     }
42583   }
42584
42585   jresult = result;
42586   return jresult;
42587 }
42588
42589
42590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42591   void * jresult ;
42592   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42593   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42594
42595   arg1 = (Dali::TapGestureDetector *)jarg1;
42596   {
42597     try {
42598       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42599     } catch (std::out_of_range& e) {
42600       {
42601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42602       };
42603     } catch (std::exception& e) {
42604       {
42605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42606       };
42607     } catch (Dali::DaliException e) {
42608       {
42609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42610       };
42611     } catch (...) {
42612       {
42613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42614       };
42615     }
42616   }
42617
42618   jresult = (void *)result;
42619   return jresult;
42620 }
42621
42622
42623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42624   void * jresult ;
42625   Dali::TapGesture *result = 0 ;
42626
42627   {
42628     try {
42629       result = (Dali::TapGesture *)new Dali::TapGesture();
42630     } catch (std::out_of_range& e) {
42631       {
42632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42633       };
42634     } catch (std::exception& e) {
42635       {
42636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42637       };
42638     } catch (Dali::DaliException e) {
42639       {
42640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42641       };
42642     } catch (...) {
42643       {
42644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42645       };
42646     }
42647   }
42648
42649   jresult = (void *)result;
42650   return jresult;
42651 }
42652
42653
42654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42655   void * jresult ;
42656   Dali::TapGesture *arg1 = 0 ;
42657   Dali::TapGesture *result = 0 ;
42658
42659   arg1 = (Dali::TapGesture *)jarg1;
42660   if (!arg1) {
42661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42662     return 0;
42663   }
42664   {
42665     try {
42666       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42667     } catch (std::out_of_range& e) {
42668       {
42669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42670       };
42671     } catch (std::exception& e) {
42672       {
42673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42674       };
42675     } catch (Dali::DaliException e) {
42676       {
42677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42678       };
42679     } catch (...) {
42680       {
42681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42682       };
42683     }
42684   }
42685
42686   jresult = (void *)result;
42687   return jresult;
42688 }
42689
42690
42691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42692   void * jresult ;
42693   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42694   Dali::TapGesture *arg2 = 0 ;
42695   Dali::TapGesture *result = 0 ;
42696
42697   arg1 = (Dali::TapGesture *)jarg1;
42698   arg2 = (Dali::TapGesture *)jarg2;
42699   if (!arg2) {
42700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42701     return 0;
42702   }
42703   {
42704     try {
42705       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42706     } catch (std::out_of_range& e) {
42707       {
42708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42709       };
42710     } catch (std::exception& e) {
42711       {
42712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42713       };
42714     } catch (Dali::DaliException e) {
42715       {
42716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42717       };
42718     } catch (...) {
42719       {
42720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42721       };
42722     }
42723   }
42724
42725   jresult = (void *)result;
42726   return jresult;
42727 }
42728
42729
42730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42731   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42732
42733   arg1 = (Dali::TapGesture *)jarg1;
42734   {
42735     try {
42736       delete arg1;
42737     } catch (std::out_of_range& e) {
42738       {
42739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42740       };
42741     } catch (std::exception& e) {
42742       {
42743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42744       };
42745     } catch (Dali::DaliException e) {
42746       {
42747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42748       };
42749     } catch (...) {
42750       {
42751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42752       };
42753     }
42754   }
42755
42756 }
42757
42758
42759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42760   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42761   unsigned int arg2 ;
42762
42763   arg1 = (Dali::TapGesture *)jarg1;
42764   arg2 = (unsigned int)jarg2;
42765   if (arg1) (arg1)->numberOfTaps = arg2;
42766 }
42767
42768
42769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42770   unsigned int jresult ;
42771   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42772   unsigned int result;
42773
42774   arg1 = (Dali::TapGesture *)jarg1;
42775   result = (unsigned int) ((arg1)->numberOfTaps);
42776   jresult = result;
42777   return jresult;
42778 }
42779
42780
42781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42782   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42783   unsigned int arg2 ;
42784
42785   arg1 = (Dali::TapGesture *)jarg1;
42786   arg2 = (unsigned int)jarg2;
42787   if (arg1) (arg1)->numberOfTouches = arg2;
42788 }
42789
42790
42791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42792   unsigned int jresult ;
42793   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42794   unsigned int result;
42795
42796   arg1 = (Dali::TapGesture *)jarg1;
42797   result = (unsigned int) ((arg1)->numberOfTouches);
42798   jresult = result;
42799   return jresult;
42800 }
42801
42802
42803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42804   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42805   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42806
42807   arg1 = (Dali::TapGesture *)jarg1;
42808   arg2 = (Dali::Vector2 *)jarg2;
42809   if (arg1) (arg1)->screenPoint = *arg2;
42810 }
42811
42812
42813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42814   void * jresult ;
42815   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42816   Dali::Vector2 *result = 0 ;
42817
42818   arg1 = (Dali::TapGesture *)jarg1;
42819   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42820   jresult = (void *)result;
42821   return jresult;
42822 }
42823
42824
42825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42826   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42827   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42828
42829   arg1 = (Dali::TapGesture *)jarg1;
42830   arg2 = (Dali::Vector2 *)jarg2;
42831   if (arg1) (arg1)->localPoint = *arg2;
42832 }
42833
42834
42835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42836   void * jresult ;
42837   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42838   Dali::Vector2 *result = 0 ;
42839
42840   arg1 = (Dali::TapGesture *)jarg1;
42841   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42842   jresult = (void *)result;
42843   return jresult;
42844 }
42845
42846
42847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42848   void * jresult ;
42849   Dali::AlphaFunction *result = 0 ;
42850
42851   {
42852     try {
42853       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42854     } catch (std::out_of_range& e) {
42855       {
42856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42857       };
42858     } catch (std::exception& e) {
42859       {
42860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42861       };
42862     } catch (Dali::DaliException e) {
42863       {
42864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42865       };
42866     } catch (...) {
42867       {
42868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42869       };
42870     }
42871   }
42872
42873   jresult = (void *)result;
42874   return jresult;
42875 }
42876
42877
42878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42879   void * jresult ;
42880   Dali::AlphaFunction::BuiltinFunction arg1 ;
42881   Dali::AlphaFunction *result = 0 ;
42882
42883   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42884   {
42885     try {
42886       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42887     } catch (std::out_of_range& e) {
42888       {
42889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42890       };
42891     } catch (std::exception& e) {
42892       {
42893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42894       };
42895     } catch (Dali::DaliException e) {
42896       {
42897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42898       };
42899     } catch (...) {
42900       {
42901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42902       };
42903     }
42904   }
42905
42906   jresult = (void *)result;
42907   return jresult;
42908 }
42909
42910
42911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42912   void * jresult ;
42913   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42914   Dali::AlphaFunction *result = 0 ;
42915
42916   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42917   {
42918     try {
42919       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42920     } catch (std::out_of_range& e) {
42921       {
42922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42923       };
42924     } catch (std::exception& e) {
42925       {
42926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (Dali::DaliException e) {
42929       {
42930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42931       };
42932     } catch (...) {
42933       {
42934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42935       };
42936     }
42937   }
42938
42939   jresult = (void *)result;
42940   return jresult;
42941 }
42942
42943
42944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42945   void * jresult ;
42946   Dali::Vector2 *arg1 = 0 ;
42947   Dali::Vector2 *arg2 = 0 ;
42948   Dali::AlphaFunction *result = 0 ;
42949
42950   arg1 = (Dali::Vector2 *)jarg1;
42951   if (!arg1) {
42952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42953     return 0;
42954   }
42955   arg2 = (Dali::Vector2 *)jarg2;
42956   if (!arg2) {
42957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42958     return 0;
42959   }
42960   {
42961     try {
42962       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42963     } catch (std::out_of_range& e) {
42964       {
42965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42966       };
42967     } catch (std::exception& e) {
42968       {
42969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42970       };
42971     } catch (Dali::DaliException e) {
42972       {
42973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42974       };
42975     } catch (...) {
42976       {
42977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42978       };
42979     }
42980   }
42981
42982   jresult = (void *)result;
42983   return jresult;
42984 }
42985
42986
42987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42988   void * jresult ;
42989   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42990   Dali::Vector4 result;
42991
42992   arg1 = (Dali::AlphaFunction *)jarg1;
42993   {
42994     try {
42995       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
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 (Dali::DaliException e) {
43005       {
43006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43007       };
43008     } catch (...) {
43009       {
43010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43011       };
43012     }
43013   }
43014
43015   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43016   return jresult;
43017 }
43018
43019
43020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43021   void * jresult ;
43022   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43023   Dali::AlphaFunctionPrototype result;
43024
43025   arg1 = (Dali::AlphaFunction *)jarg1;
43026   {
43027     try {
43028       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43029     } catch (std::out_of_range& e) {
43030       {
43031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43032       };
43033     } catch (std::exception& e) {
43034       {
43035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43036       };
43037     } catch (Dali::DaliException e) {
43038       {
43039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43040       };
43041     } catch (...) {
43042       {
43043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43044       };
43045     }
43046   }
43047
43048   jresult = (void *)result;
43049   return jresult;
43050 }
43051
43052
43053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43054   int jresult ;
43055   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43056   Dali::AlphaFunction::BuiltinFunction result;
43057
43058   arg1 = (Dali::AlphaFunction *)jarg1;
43059   {
43060     try {
43061       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43062     } catch (std::out_of_range& e) {
43063       {
43064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43065       };
43066     } catch (std::exception& e) {
43067       {
43068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43069       };
43070     } catch (Dali::DaliException e) {
43071       {
43072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43073       };
43074     } catch (...) {
43075       {
43076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43077       };
43078     }
43079   }
43080
43081   jresult = (int)result;
43082   return jresult;
43083 }
43084
43085
43086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43087   int jresult ;
43088   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43089   Dali::AlphaFunction::Mode result;
43090
43091   arg1 = (Dali::AlphaFunction *)jarg1;
43092   {
43093     try {
43094       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43095     } catch (std::out_of_range& e) {
43096       {
43097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43098       };
43099     } catch (std::exception& e) {
43100       {
43101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43102       };
43103     } catch (Dali::DaliException e) {
43104       {
43105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43106       };
43107     } catch (...) {
43108       {
43109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43110       };
43111     }
43112   }
43113
43114   jresult = (int)result;
43115   return jresult;
43116 }
43117
43118
43119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43120   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43121
43122   arg1 = (Dali::AlphaFunction *)jarg1;
43123   {
43124     try {
43125       delete arg1;
43126     } catch (std::out_of_range& e) {
43127       {
43128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43129       };
43130     } catch (std::exception& e) {
43131       {
43132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43133       };
43134     } catch (Dali::DaliException e) {
43135       {
43136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43137       };
43138     } catch (...) {
43139       {
43140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43141       };
43142     }
43143   }
43144
43145 }
43146
43147
43148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43149   void * jresult ;
43150   Dali::KeyFrames result;
43151
43152   {
43153     try {
43154       result = Dali::KeyFrames::New();
43155     } catch (std::out_of_range& e) {
43156       {
43157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43158       };
43159     } catch (std::exception& e) {
43160       {
43161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43162       };
43163     } catch (Dali::DaliException e) {
43164       {
43165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43166       };
43167     } catch (...) {
43168       {
43169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43170       };
43171     }
43172   }
43173
43174   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43175   return jresult;
43176 }
43177
43178
43179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43180   void * jresult ;
43181   Dali::BaseHandle arg1 ;
43182   Dali::BaseHandle *argp1 ;
43183   Dali::KeyFrames result;
43184
43185   argp1 = (Dali::BaseHandle *)jarg1;
43186   if (!argp1) {
43187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43188     return 0;
43189   }
43190   arg1 = *argp1;
43191   {
43192     try {
43193       result = Dali::KeyFrames::DownCast(arg1);
43194     } catch (std::out_of_range& e) {
43195       {
43196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43197       };
43198     } catch (std::exception& e) {
43199       {
43200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43201       };
43202     } catch (Dali::DaliException e) {
43203       {
43204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43205       };
43206     } catch (...) {
43207       {
43208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43209       };
43210     }
43211   }
43212
43213   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43214   return jresult;
43215 }
43216
43217
43218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43219   void * jresult ;
43220   Dali::KeyFrames *result = 0 ;
43221
43222   {
43223     try {
43224       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43225     } catch (std::out_of_range& e) {
43226       {
43227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43228       };
43229     } catch (std::exception& e) {
43230       {
43231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43232       };
43233     } catch (Dali::DaliException e) {
43234       {
43235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43236       };
43237     } catch (...) {
43238       {
43239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43240       };
43241     }
43242   }
43243
43244   jresult = (void *)result;
43245   return jresult;
43246 }
43247
43248
43249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43250   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43251
43252   arg1 = (Dali::KeyFrames *)jarg1;
43253   {
43254     try {
43255       delete arg1;
43256     } catch (std::out_of_range& e) {
43257       {
43258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43259       };
43260     } catch (std::exception& e) {
43261       {
43262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43263       };
43264     } catch (Dali::DaliException e) {
43265       {
43266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43267       };
43268     } catch (...) {
43269       {
43270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43271       };
43272     }
43273   }
43274
43275 }
43276
43277
43278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43279   void * jresult ;
43280   Dali::KeyFrames *arg1 = 0 ;
43281   Dali::KeyFrames *result = 0 ;
43282
43283   arg1 = (Dali::KeyFrames *)jarg1;
43284   if (!arg1) {
43285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43286     return 0;
43287   }
43288   {
43289     try {
43290       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43291     } catch (std::out_of_range& e) {
43292       {
43293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43294       };
43295     } catch (std::exception& e) {
43296       {
43297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43298       };
43299     } catch (Dali::DaliException e) {
43300       {
43301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43302       };
43303     } catch (...) {
43304       {
43305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43306       };
43307     }
43308   }
43309
43310   jresult = (void *)result;
43311   return jresult;
43312 }
43313
43314
43315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43316   void * jresult ;
43317   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43318   Dali::KeyFrames *arg2 = 0 ;
43319   Dali::KeyFrames *result = 0 ;
43320
43321   arg1 = (Dali::KeyFrames *)jarg1;
43322   arg2 = (Dali::KeyFrames *)jarg2;
43323   if (!arg2) {
43324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43325     return 0;
43326   }
43327   {
43328     try {
43329       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43330     } catch (std::out_of_range& e) {
43331       {
43332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43333       };
43334     } catch (std::exception& e) {
43335       {
43336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43337       };
43338     } catch (Dali::DaliException e) {
43339       {
43340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43341       };
43342     } catch (...) {
43343       {
43344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43345       };
43346     }
43347   }
43348
43349   jresult = (void *)result;
43350   return jresult;
43351 }
43352
43353
43354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43355   int jresult ;
43356   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43357   Dali::Property::Type result;
43358
43359   arg1 = (Dali::KeyFrames *)jarg1;
43360   {
43361     try {
43362       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43363     } catch (std::out_of_range& e) {
43364       {
43365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43366       };
43367     } catch (std::exception& e) {
43368       {
43369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43370       };
43371     } catch (Dali::DaliException e) {
43372       {
43373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43374       };
43375     } catch (...) {
43376       {
43377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43378       };
43379     }
43380   }
43381
43382   jresult = (int)result;
43383   return jresult;
43384 }
43385
43386
43387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43388   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43389   float arg2 ;
43390   Dali::Property::Value arg3 ;
43391   Dali::Property::Value *argp3 ;
43392
43393   arg1 = (Dali::KeyFrames *)jarg1;
43394   arg2 = (float)jarg2;
43395   argp3 = (Dali::Property::Value *)jarg3;
43396   if (!argp3) {
43397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43398     return ;
43399   }
43400   arg3 = *argp3;
43401   {
43402     try {
43403       (arg1)->Add(arg2,arg3);
43404     } catch (std::out_of_range& e) {
43405       {
43406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43407       };
43408     } catch (std::exception& e) {
43409       {
43410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43411       };
43412     } catch (Dali::DaliException e) {
43413       {
43414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43415       };
43416     } catch (...) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43419       };
43420     }
43421   }
43422
43423 }
43424
43425
43426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43427   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43428   float arg2 ;
43429   Dali::Property::Value arg3 ;
43430   Dali::AlphaFunction arg4 ;
43431   Dali::Property::Value *argp3 ;
43432   Dali::AlphaFunction *argp4 ;
43433
43434   arg1 = (Dali::KeyFrames *)jarg1;
43435   arg2 = (float)jarg2;
43436   argp3 = (Dali::Property::Value *)jarg3;
43437   if (!argp3) {
43438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43439     return ;
43440   }
43441   arg3 = *argp3;
43442   argp4 = (Dali::AlphaFunction *)jarg4;
43443   if (!argp4) {
43444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43445     return ;
43446   }
43447   arg4 = *argp4;
43448   {
43449     try {
43450       (arg1)->Add(arg2,arg3,arg4);
43451     } catch (std::out_of_range& e) {
43452       {
43453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43454       };
43455     } catch (std::exception& e) {
43456       {
43457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43458       };
43459     } catch (Dali::DaliException e) {
43460       {
43461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43462       };
43463     } catch (...) {
43464       {
43465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43466       };
43467     }
43468   }
43469
43470 }
43471
43472
43473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43474   int jresult ;
43475   int result;
43476
43477   result = (int)Dali::Path::Property::POINTS;
43478   jresult = (int)result;
43479   return jresult;
43480 }
43481
43482
43483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43484   int jresult ;
43485   int result;
43486
43487   result = (int)Dali::Path::Property::CONTROL_POINTS;
43488   jresult = (int)result;
43489   return jresult;
43490 }
43491
43492
43493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43494   void * jresult ;
43495   Dali::Path::Property *result = 0 ;
43496
43497   {
43498     try {
43499       result = (Dali::Path::Property *)new Dali::Path::Property();
43500     } catch (std::out_of_range& e) {
43501       {
43502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43503       };
43504     } catch (std::exception& e) {
43505       {
43506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43507       };
43508     } catch (Dali::DaliException e) {
43509       {
43510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43511       };
43512     } catch (...) {
43513       {
43514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43515       };
43516     }
43517   }
43518
43519   jresult = (void *)result;
43520   return jresult;
43521 }
43522
43523
43524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43525   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43526
43527   arg1 = (Dali::Path::Property *)jarg1;
43528   {
43529     try {
43530       delete arg1;
43531     } catch (std::out_of_range& e) {
43532       {
43533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43534       };
43535     } catch (std::exception& e) {
43536       {
43537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43538       };
43539     } catch (Dali::DaliException e) {
43540       {
43541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43542       };
43543     } catch (...) {
43544       {
43545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43546       };
43547     }
43548   }
43549
43550 }
43551
43552
43553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43554   void * jresult ;
43555   Dali::Path result;
43556
43557   {
43558     try {
43559       result = Dali::Path::New();
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 (Dali::DaliException e) {
43569       {
43570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43571       };
43572     } catch (...) {
43573       {
43574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43575       };
43576     }
43577   }
43578
43579   jresult = new Dali::Path((const Dali::Path &)result);
43580   return jresult;
43581 }
43582
43583
43584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43585   void * jresult ;
43586   Dali::BaseHandle arg1 ;
43587   Dali::BaseHandle *argp1 ;
43588   Dali::Path result;
43589
43590   argp1 = (Dali::BaseHandle *)jarg1;
43591   if (!argp1) {
43592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43593     return 0;
43594   }
43595   arg1 = *argp1;
43596   {
43597     try {
43598       result = Dali::Path::DownCast(arg1);
43599     } catch (std::out_of_range& e) {
43600       {
43601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43602       };
43603     } catch (std::exception& e) {
43604       {
43605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43606       };
43607     } catch (Dali::DaliException e) {
43608       {
43609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43610       };
43611     } catch (...) {
43612       {
43613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43614       };
43615     }
43616   }
43617
43618   jresult = new Dali::Path((const Dali::Path &)result);
43619   return jresult;
43620 }
43621
43622
43623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43624   void * jresult ;
43625   Dali::Path *result = 0 ;
43626
43627   {
43628     try {
43629       result = (Dali::Path *)new Dali::Path();
43630     } catch (std::out_of_range& e) {
43631       {
43632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43633       };
43634     } catch (std::exception& e) {
43635       {
43636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43637       };
43638     } catch (Dali::DaliException e) {
43639       {
43640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43641       };
43642     } catch (...) {
43643       {
43644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43645       };
43646     }
43647   }
43648
43649   jresult = (void *)result;
43650   return jresult;
43651 }
43652
43653
43654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43655   Dali::Path *arg1 = (Dali::Path *) 0 ;
43656
43657   arg1 = (Dali::Path *)jarg1;
43658   {
43659     try {
43660       delete arg1;
43661     } catch (std::out_of_range& e) {
43662       {
43663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43664       };
43665     } catch (std::exception& e) {
43666       {
43667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43668       };
43669     } catch (Dali::DaliException e) {
43670       {
43671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43672       };
43673     } catch (...) {
43674       {
43675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43676       };
43677     }
43678   }
43679
43680 }
43681
43682
43683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43684   void * jresult ;
43685   Dali::Path *arg1 = 0 ;
43686   Dali::Path *result = 0 ;
43687
43688   arg1 = (Dali::Path *)jarg1;
43689   if (!arg1) {
43690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43691     return 0;
43692   }
43693   {
43694     try {
43695       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43696     } catch (std::out_of_range& e) {
43697       {
43698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43699       };
43700     } catch (std::exception& e) {
43701       {
43702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43703       };
43704     } catch (Dali::DaliException e) {
43705       {
43706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43707       };
43708     } catch (...) {
43709       {
43710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43711       };
43712     }
43713   }
43714
43715   jresult = (void *)result;
43716   return jresult;
43717 }
43718
43719
43720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43721   void * jresult ;
43722   Dali::Path *arg1 = (Dali::Path *) 0 ;
43723   Dali::Path *arg2 = 0 ;
43724   Dali::Path *result = 0 ;
43725
43726   arg1 = (Dali::Path *)jarg1;
43727   arg2 = (Dali::Path *)jarg2;
43728   if (!arg2) {
43729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43730     return 0;
43731   }
43732   {
43733     try {
43734       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43735     } catch (std::out_of_range& e) {
43736       {
43737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43738       };
43739     } catch (std::exception& e) {
43740       {
43741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43742       };
43743     } catch (Dali::DaliException e) {
43744       {
43745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43746       };
43747     } catch (...) {
43748       {
43749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43750       };
43751     }
43752   }
43753
43754   jresult = (void *)result;
43755   return jresult;
43756 }
43757
43758
43759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43760   Dali::Path *arg1 = (Dali::Path *) 0 ;
43761   Dali::Vector3 *arg2 = 0 ;
43762
43763   arg1 = (Dali::Path *)jarg1;
43764   arg2 = (Dali::Vector3 *)jarg2;
43765   if (!arg2) {
43766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43767     return ;
43768   }
43769   {
43770     try {
43771       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43772     } catch (std::out_of_range& e) {
43773       {
43774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43775       };
43776     } catch (std::exception& e) {
43777       {
43778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43779       };
43780     } catch (Dali::DaliException e) {
43781       {
43782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43783       };
43784     } catch (...) {
43785       {
43786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43787       };
43788     }
43789   }
43790
43791 }
43792
43793
43794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43795   Dali::Path *arg1 = (Dali::Path *) 0 ;
43796   Dali::Vector3 *arg2 = 0 ;
43797
43798   arg1 = (Dali::Path *)jarg1;
43799   arg2 = (Dali::Vector3 *)jarg2;
43800   if (!arg2) {
43801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43802     return ;
43803   }
43804   {
43805     try {
43806       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43807     } catch (std::out_of_range& e) {
43808       {
43809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43810       };
43811     } catch (std::exception& e) {
43812       {
43813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43814       };
43815     } catch (Dali::DaliException e) {
43816       {
43817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43818       };
43819     } catch (...) {
43820       {
43821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43822       };
43823     }
43824   }
43825
43826 }
43827
43828
43829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43830   Dali::Path *arg1 = (Dali::Path *) 0 ;
43831   float arg2 ;
43832
43833   arg1 = (Dali::Path *)jarg1;
43834   arg2 = (float)jarg2;
43835   {
43836     try {
43837       (arg1)->GenerateControlPoints(arg2);
43838     } catch (std::out_of_range& e) {
43839       {
43840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43841       };
43842     } catch (std::exception& e) {
43843       {
43844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43845       };
43846     } catch (Dali::DaliException e) {
43847       {
43848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43849       };
43850     } catch (...) {
43851       {
43852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43853       };
43854     }
43855   }
43856
43857 }
43858
43859
43860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43861   Dali::Path *arg1 = (Dali::Path *) 0 ;
43862   float arg2 ;
43863   Dali::Vector3 *arg3 = 0 ;
43864   Dali::Vector3 *arg4 = 0 ;
43865
43866   arg1 = (Dali::Path *)jarg1;
43867   arg2 = (float)jarg2;
43868   arg3 = (Dali::Vector3 *)jarg3;
43869   if (!arg3) {
43870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43871     return ;
43872   }
43873   arg4 = (Dali::Vector3 *)jarg4;
43874   if (!arg4) {
43875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43876     return ;
43877   }
43878   {
43879     try {
43880       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43881     } catch (std::out_of_range& e) {
43882       {
43883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43884       };
43885     } catch (std::exception& e) {
43886       {
43887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43888       };
43889     } catch (Dali::DaliException e) {
43890       {
43891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43892       };
43893     } catch (...) {
43894       {
43895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43896       };
43897     }
43898   }
43899
43900 }
43901
43902
43903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43904   void * jresult ;
43905   Dali::Path *arg1 = (Dali::Path *) 0 ;
43906   size_t arg2 ;
43907   Dali::Vector3 *result = 0 ;
43908
43909   arg1 = (Dali::Path *)jarg1;
43910   arg2 = (size_t)jarg2;
43911   {
43912     try {
43913       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43914     } catch (std::out_of_range& e) {
43915       {
43916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43917       };
43918     } catch (std::exception& e) {
43919       {
43920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43921       };
43922     } catch (Dali::DaliException e) {
43923       {
43924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43925       };
43926     } catch (...) {
43927       {
43928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43929       };
43930     }
43931   }
43932
43933   jresult = (void *)result;
43934   return jresult;
43935 }
43936
43937
43938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43939   void * jresult ;
43940   Dali::Path *arg1 = (Dali::Path *) 0 ;
43941   size_t arg2 ;
43942   Dali::Vector3 *result = 0 ;
43943
43944   arg1 = (Dali::Path *)jarg1;
43945   arg2 = (size_t)jarg2;
43946   {
43947     try {
43948       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43949     } catch (std::out_of_range& e) {
43950       {
43951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43952       };
43953     } catch (std::exception& e) {
43954       {
43955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43956       };
43957     } catch (Dali::DaliException e) {
43958       {
43959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43960       };
43961     } catch (...) {
43962       {
43963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43964       };
43965     }
43966   }
43967
43968   jresult = (void *)result;
43969   return jresult;
43970 }
43971
43972
43973 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43974   unsigned long jresult ;
43975   Dali::Path *arg1 = (Dali::Path *) 0 ;
43976   size_t result;
43977
43978   arg1 = (Dali::Path *)jarg1;
43979   {
43980     try {
43981       result = ((Dali::Path const *)arg1)->GetPointCount();
43982     } catch (std::out_of_range& e) {
43983       {
43984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43985       };
43986     } catch (std::exception& e) {
43987       {
43988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43989       };
43990     } catch (Dali::DaliException e) {
43991       {
43992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43993       };
43994     } catch (...) {
43995       {
43996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43997       };
43998     }
43999   }
44000
44001   jresult = (unsigned long)result;
44002   return jresult;
44003 }
44004
44005
44006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44007   void * jresult ;
44008   float arg1 ;
44009   Dali::TimePeriod *result = 0 ;
44010
44011   arg1 = (float)jarg1;
44012   {
44013     try {
44014       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44015     } catch (std::out_of_range& e) {
44016       {
44017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44018       };
44019     } catch (std::exception& e) {
44020       {
44021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44022       };
44023     } catch (Dali::DaliException e) {
44024       {
44025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44026       };
44027     } catch (...) {
44028       {
44029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44030       };
44031     }
44032   }
44033
44034   jresult = (void *)result;
44035   return jresult;
44036 }
44037
44038
44039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44040   void * jresult ;
44041   float arg1 ;
44042   float arg2 ;
44043   Dali::TimePeriod *result = 0 ;
44044
44045   arg1 = (float)jarg1;
44046   arg2 = (float)jarg2;
44047   {
44048     try {
44049       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44050     } catch (std::out_of_range& e) {
44051       {
44052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44053       };
44054     } catch (std::exception& e) {
44055       {
44056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44057       };
44058     } catch (Dali::DaliException e) {
44059       {
44060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44061       };
44062     } catch (...) {
44063       {
44064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44065       };
44066     }
44067   }
44068
44069   jresult = (void *)result;
44070   return jresult;
44071 }
44072
44073
44074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44075   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44076
44077   arg1 = (Dali::TimePeriod *)jarg1;
44078   {
44079     try {
44080       delete arg1;
44081     } catch (std::out_of_range& e) {
44082       {
44083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44084       };
44085     } catch (std::exception& e) {
44086       {
44087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44088       };
44089     } catch (Dali::DaliException e) {
44090       {
44091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44092       };
44093     } catch (...) {
44094       {
44095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44096       };
44097     }
44098   }
44099
44100 }
44101
44102
44103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44104   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44105   float arg2 ;
44106
44107   arg1 = (Dali::TimePeriod *)jarg1;
44108   arg2 = (float)jarg2;
44109   if (arg1) (arg1)->delaySeconds = arg2;
44110 }
44111
44112
44113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44114   float jresult ;
44115   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44116   float result;
44117
44118   arg1 = (Dali::TimePeriod *)jarg1;
44119   result = (float) ((arg1)->delaySeconds);
44120   jresult = result;
44121   return jresult;
44122 }
44123
44124
44125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44126   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44127   float arg2 ;
44128
44129   arg1 = (Dali::TimePeriod *)jarg1;
44130   arg2 = (float)jarg2;
44131   if (arg1) (arg1)->durationSeconds = arg2;
44132 }
44133
44134
44135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44136   float jresult ;
44137   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44138   float result;
44139
44140   arg1 = (Dali::TimePeriod *)jarg1;
44141   result = (float) ((arg1)->durationSeconds);
44142   jresult = result;
44143   return jresult;
44144 }
44145
44146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44147   int jresult ;
44148   int result;
44149
44150   result = (int)Dali::LinearConstrainer::Property::VALUE;
44151   jresult = (int)result;
44152   return jresult;
44153 }
44154
44155
44156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44157   int jresult ;
44158   int result;
44159
44160   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44161   jresult = (int)result;
44162   return jresult;
44163 }
44164
44165
44166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44167   void * jresult ;
44168   Dali::LinearConstrainer::Property *result = 0 ;
44169
44170   {
44171     try {
44172       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44173     } catch (std::out_of_range& e) {
44174       {
44175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44176       };
44177     } catch (std::exception& e) {
44178       {
44179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44180       };
44181     } catch (Dali::DaliException e) {
44182       {
44183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44184       };
44185     } catch (...) {
44186       {
44187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44188       };
44189     }
44190   }
44191
44192   jresult = (void *)result;
44193   return jresult;
44194 }
44195
44196
44197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44198   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44199
44200   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44201   {
44202     try {
44203       delete arg1;
44204     } catch (std::out_of_range& e) {
44205       {
44206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44207       };
44208     } catch (std::exception& e) {
44209       {
44210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44211       };
44212     } catch (Dali::DaliException e) {
44213       {
44214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44215       };
44216     } catch (...) {
44217       {
44218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44219       };
44220     }
44221   }
44222
44223 }
44224
44225
44226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44227   void * jresult ;
44228   Dali::LinearConstrainer result;
44229
44230   {
44231     try {
44232       result = Dali::LinearConstrainer::New();
44233     } catch (std::out_of_range& e) {
44234       {
44235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44236       };
44237     } catch (std::exception& e) {
44238       {
44239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44240       };
44241     } catch (Dali::DaliException e) {
44242       {
44243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44244       };
44245     } catch (...) {
44246       {
44247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44248       };
44249     }
44250   }
44251
44252   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44253   return jresult;
44254 }
44255
44256
44257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44258   void * jresult ;
44259   Dali::BaseHandle arg1 ;
44260   Dali::BaseHandle *argp1 ;
44261   Dali::LinearConstrainer result;
44262
44263   argp1 = (Dali::BaseHandle *)jarg1;
44264   if (!argp1) {
44265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44266     return 0;
44267   }
44268   arg1 = *argp1;
44269   {
44270     try {
44271       result = Dali::LinearConstrainer::DownCast(arg1);
44272     } catch (std::out_of_range& e) {
44273       {
44274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44275       };
44276     } catch (std::exception& e) {
44277       {
44278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44279       };
44280     } catch (Dali::DaliException e) {
44281       {
44282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44283       };
44284     } catch (...) {
44285       {
44286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44287       };
44288     }
44289   }
44290
44291   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44292   return jresult;
44293 }
44294
44295
44296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44297   void * jresult ;
44298   Dali::LinearConstrainer *result = 0 ;
44299
44300   {
44301     try {
44302       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44303     } catch (std::out_of_range& e) {
44304       {
44305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44306       };
44307     } catch (std::exception& e) {
44308       {
44309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44310       };
44311     } catch (Dali::DaliException e) {
44312       {
44313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44314       };
44315     } catch (...) {
44316       {
44317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44318       };
44319     }
44320   }
44321
44322   jresult = (void *)result;
44323   return jresult;
44324 }
44325
44326
44327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44328   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44329
44330   arg1 = (Dali::LinearConstrainer *)jarg1;
44331   {
44332     try {
44333       delete arg1;
44334     } catch (std::out_of_range& e) {
44335       {
44336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44337       };
44338     } catch (std::exception& e) {
44339       {
44340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44341       };
44342     } catch (Dali::DaliException e) {
44343       {
44344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44345       };
44346     } catch (...) {
44347       {
44348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44349       };
44350     }
44351   }
44352
44353 }
44354
44355
44356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44357   void * jresult ;
44358   Dali::LinearConstrainer *arg1 = 0 ;
44359   Dali::LinearConstrainer *result = 0 ;
44360
44361   arg1 = (Dali::LinearConstrainer *)jarg1;
44362   if (!arg1) {
44363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44364     return 0;
44365   }
44366   {
44367     try {
44368       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44369     } catch (std::out_of_range& e) {
44370       {
44371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44372       };
44373     } catch (std::exception& e) {
44374       {
44375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44376       };
44377     } catch (Dali::DaliException e) {
44378       {
44379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44380       };
44381     } catch (...) {
44382       {
44383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44384       };
44385     }
44386   }
44387
44388   jresult = (void *)result;
44389   return jresult;
44390 }
44391
44392
44393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44394   void * jresult ;
44395   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44396   Dali::LinearConstrainer *arg2 = 0 ;
44397   Dali::LinearConstrainer *result = 0 ;
44398
44399   arg1 = (Dali::LinearConstrainer *)jarg1;
44400   arg2 = (Dali::LinearConstrainer *)jarg2;
44401   if (!arg2) {
44402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44403     return 0;
44404   }
44405   {
44406     try {
44407       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44408     } catch (std::out_of_range& e) {
44409       {
44410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44411       };
44412     } catch (std::exception& e) {
44413       {
44414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44415       };
44416     } catch (Dali::DaliException e) {
44417       {
44418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44419       };
44420     } catch (...) {
44421       {
44422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44423       };
44424     }
44425   }
44426
44427   jresult = (void *)result;
44428   return jresult;
44429 }
44430
44431
44432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44433   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44434   SwigValueWrapper< Dali::Property > arg2 ;
44435   SwigValueWrapper< Dali::Property > arg3 ;
44436   Dali::Vector2 *arg4 = 0 ;
44437   Dali::Vector2 *arg5 = 0 ;
44438   Dali::Property *argp2 ;
44439   Dali::Property *argp3 ;
44440
44441   arg1 = (Dali::LinearConstrainer *)jarg1;
44442   argp2 = (Dali::Property *)jarg2;
44443   if (!argp2) {
44444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44445     return ;
44446   }
44447   arg2 = *argp2;
44448   argp3 = (Dali::Property *)jarg3;
44449   if (!argp3) {
44450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44451     return ;
44452   }
44453   arg3 = *argp3;
44454   arg4 = (Dali::Vector2 *)jarg4;
44455   if (!arg4) {
44456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44457     return ;
44458   }
44459   arg5 = (Dali::Vector2 *)jarg5;
44460   if (!arg5) {
44461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44462     return ;
44463   }
44464   {
44465     try {
44466       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44467     } catch (std::out_of_range& e) {
44468       {
44469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44470       };
44471     } catch (std::exception& e) {
44472       {
44473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44474       };
44475     } catch (Dali::DaliException e) {
44476       {
44477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44478       };
44479     } catch (...) {
44480       {
44481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44482       };
44483     }
44484   }
44485
44486 }
44487
44488
44489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44490   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44491   SwigValueWrapper< Dali::Property > arg2 ;
44492   SwigValueWrapper< Dali::Property > arg3 ;
44493   Dali::Vector2 *arg4 = 0 ;
44494   Dali::Property *argp2 ;
44495   Dali::Property *argp3 ;
44496
44497   arg1 = (Dali::LinearConstrainer *)jarg1;
44498   argp2 = (Dali::Property *)jarg2;
44499   if (!argp2) {
44500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44501     return ;
44502   }
44503   arg2 = *argp2;
44504   argp3 = (Dali::Property *)jarg3;
44505   if (!argp3) {
44506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44507     return ;
44508   }
44509   arg3 = *argp3;
44510   arg4 = (Dali::Vector2 *)jarg4;
44511   if (!arg4) {
44512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44513     return ;
44514   }
44515   {
44516     try {
44517       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44518     } catch (std::out_of_range& e) {
44519       {
44520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44521       };
44522     } catch (std::exception& e) {
44523       {
44524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44525       };
44526     } catch (Dali::DaliException e) {
44527       {
44528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44529       };
44530     } catch (...) {
44531       {
44532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44533       };
44534     }
44535   }
44536
44537 }
44538
44539
44540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44541   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44542   Dali::Handle *arg2 = 0 ;
44543
44544   arg1 = (Dali::LinearConstrainer *)jarg1;
44545   arg2 = (Dali::Handle *)jarg2;
44546   if (!arg2) {
44547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44548     return ;
44549   }
44550   {
44551     try {
44552       (arg1)->Remove(*arg2);
44553     } catch (std::out_of_range& e) {
44554       {
44555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44556       };
44557     } catch (std::exception& e) {
44558       {
44559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44560       };
44561     } catch (Dali::DaliException e) {
44562       {
44563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44564       };
44565     } catch (...) {
44566       {
44567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44568       };
44569     }
44570   }
44571
44572 }
44573
44574
44575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44576   int jresult ;
44577   int result;
44578
44579   result = (int)Dali::PathConstrainer::Property::FORWARD;
44580   jresult = (int)result;
44581   return jresult;
44582 }
44583
44584
44585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44586   int jresult ;
44587   int result;
44588
44589   result = (int)Dali::PathConstrainer::Property::POINTS;
44590   jresult = (int)result;
44591   return jresult;
44592 }
44593
44594
44595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44596   int jresult ;
44597   int result;
44598
44599   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44600   jresult = (int)result;
44601   return jresult;
44602 }
44603
44604
44605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44606   void * jresult ;
44607   Dali::PathConstrainer::Property *result = 0 ;
44608
44609   {
44610     try {
44611       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44612     } catch (std::out_of_range& e) {
44613       {
44614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44615       };
44616     } catch (std::exception& e) {
44617       {
44618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44619       };
44620     } catch (Dali::DaliException e) {
44621       {
44622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44623       };
44624     } catch (...) {
44625       {
44626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44627       };
44628     }
44629   }
44630
44631   jresult = (void *)result;
44632   return jresult;
44633 }
44634
44635
44636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44637   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44638
44639   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44640   {
44641     try {
44642       delete arg1;
44643     } catch (std::out_of_range& e) {
44644       {
44645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44646       };
44647     } catch (std::exception& e) {
44648       {
44649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44650       };
44651     } catch (Dali::DaliException e) {
44652       {
44653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44654       };
44655     } catch (...) {
44656       {
44657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44658       };
44659     }
44660   }
44661
44662 }
44663
44664
44665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44666   void * jresult ;
44667   Dali::PathConstrainer result;
44668
44669   {
44670     try {
44671       result = Dali::PathConstrainer::New();
44672     } catch (std::out_of_range& e) {
44673       {
44674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44675       };
44676     } catch (std::exception& e) {
44677       {
44678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44679       };
44680     } catch (Dali::DaliException e) {
44681       {
44682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44683       };
44684     } catch (...) {
44685       {
44686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44687       };
44688     }
44689   }
44690
44691   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44692   return jresult;
44693 }
44694
44695
44696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44697   void * jresult ;
44698   Dali::BaseHandle arg1 ;
44699   Dali::BaseHandle *argp1 ;
44700   Dali::PathConstrainer result;
44701
44702   argp1 = (Dali::BaseHandle *)jarg1;
44703   if (!argp1) {
44704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44705     return 0;
44706   }
44707   arg1 = *argp1;
44708   {
44709     try {
44710       result = Dali::PathConstrainer::DownCast(arg1);
44711     } catch (std::out_of_range& e) {
44712       {
44713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44714       };
44715     } catch (std::exception& e) {
44716       {
44717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44718       };
44719     } catch (Dali::DaliException e) {
44720       {
44721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44722       };
44723     } catch (...) {
44724       {
44725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44726       };
44727     }
44728   }
44729
44730   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44731   return jresult;
44732 }
44733
44734
44735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44736   void * jresult ;
44737   Dali::PathConstrainer *result = 0 ;
44738
44739   {
44740     try {
44741       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44742     } catch (std::out_of_range& e) {
44743       {
44744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44745       };
44746     } catch (std::exception& e) {
44747       {
44748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44749       };
44750     } catch (Dali::DaliException e) {
44751       {
44752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44753       };
44754     } catch (...) {
44755       {
44756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44757       };
44758     }
44759   }
44760
44761   jresult = (void *)result;
44762   return jresult;
44763 }
44764
44765
44766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44767   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44768
44769   arg1 = (Dali::PathConstrainer *)jarg1;
44770   {
44771     try {
44772       delete arg1;
44773     } catch (std::out_of_range& e) {
44774       {
44775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44776       };
44777     } catch (std::exception& e) {
44778       {
44779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44780       };
44781     } catch (Dali::DaliException e) {
44782       {
44783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44784       };
44785     } catch (...) {
44786       {
44787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44788       };
44789     }
44790   }
44791
44792 }
44793
44794
44795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44796   void * jresult ;
44797   Dali::PathConstrainer *arg1 = 0 ;
44798   Dali::PathConstrainer *result = 0 ;
44799
44800   arg1 = (Dali::PathConstrainer *)jarg1;
44801   if (!arg1) {
44802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44803     return 0;
44804   }
44805   {
44806     try {
44807       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44808     } catch (std::out_of_range& e) {
44809       {
44810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44811       };
44812     } catch (std::exception& e) {
44813       {
44814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44815       };
44816     } catch (Dali::DaliException e) {
44817       {
44818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44819       };
44820     } catch (...) {
44821       {
44822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44823       };
44824     }
44825   }
44826
44827   jresult = (void *)result;
44828   return jresult;
44829 }
44830
44831
44832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44833   void * jresult ;
44834   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44835   Dali::PathConstrainer *arg2 = 0 ;
44836   Dali::PathConstrainer *result = 0 ;
44837
44838   arg1 = (Dali::PathConstrainer *)jarg1;
44839   arg2 = (Dali::PathConstrainer *)jarg2;
44840   if (!arg2) {
44841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44842     return 0;
44843   }
44844   {
44845     try {
44846       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44847     } catch (std::out_of_range& e) {
44848       {
44849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44850       };
44851     } catch (std::exception& e) {
44852       {
44853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44854       };
44855     } catch (Dali::DaliException e) {
44856       {
44857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44858       };
44859     } catch (...) {
44860       {
44861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44862       };
44863     }
44864   }
44865
44866   jresult = (void *)result;
44867   return jresult;
44868 }
44869
44870
44871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44872   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44873   SwigValueWrapper< Dali::Property > arg2 ;
44874   SwigValueWrapper< Dali::Property > arg3 ;
44875   Dali::Vector2 *arg4 = 0 ;
44876   Dali::Vector2 *arg5 = 0 ;
44877   Dali::Property *argp2 ;
44878   Dali::Property *argp3 ;
44879
44880   arg1 = (Dali::PathConstrainer *)jarg1;
44881   argp2 = (Dali::Property *)jarg2;
44882   if (!argp2) {
44883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44884     return ;
44885   }
44886   arg2 = *argp2;
44887   argp3 = (Dali::Property *)jarg3;
44888   if (!argp3) {
44889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44890     return ;
44891   }
44892   arg3 = *argp3;
44893   arg4 = (Dali::Vector2 *)jarg4;
44894   if (!arg4) {
44895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44896     return ;
44897   }
44898   arg5 = (Dali::Vector2 *)jarg5;
44899   if (!arg5) {
44900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44901     return ;
44902   }
44903   {
44904     try {
44905       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44906     } catch (std::out_of_range& e) {
44907       {
44908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44909       };
44910     } catch (std::exception& e) {
44911       {
44912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44913       };
44914     } catch (Dali::DaliException e) {
44915       {
44916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44917       };
44918     } catch (...) {
44919       {
44920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44921       };
44922     }
44923   }
44924
44925 }
44926
44927
44928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44929   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44930   SwigValueWrapper< Dali::Property > arg2 ;
44931   SwigValueWrapper< Dali::Property > arg3 ;
44932   Dali::Vector2 *arg4 = 0 ;
44933   Dali::Property *argp2 ;
44934   Dali::Property *argp3 ;
44935
44936   arg1 = (Dali::PathConstrainer *)jarg1;
44937   argp2 = (Dali::Property *)jarg2;
44938   if (!argp2) {
44939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44940     return ;
44941   }
44942   arg2 = *argp2;
44943   argp3 = (Dali::Property *)jarg3;
44944   if (!argp3) {
44945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44946     return ;
44947   }
44948   arg3 = *argp3;
44949   arg4 = (Dali::Vector2 *)jarg4;
44950   if (!arg4) {
44951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44952     return ;
44953   }
44954   {
44955     try {
44956       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44957     } catch (std::out_of_range& e) {
44958       {
44959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44960       };
44961     } catch (std::exception& e) {
44962       {
44963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44964       };
44965     } catch (Dali::DaliException e) {
44966       {
44967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44968       };
44969     } catch (...) {
44970       {
44971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44972       };
44973     }
44974   }
44975
44976 }
44977
44978
44979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44980   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44981   Dali::Handle *arg2 = 0 ;
44982
44983   arg1 = (Dali::PathConstrainer *)jarg1;
44984   arg2 = (Dali::Handle *)jarg2;
44985   if (!arg2) {
44986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44987     return ;
44988   }
44989   {
44990     try {
44991       (arg1)->Remove(*arg2);
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 (Dali::DaliException e) {
45001       {
45002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45003       };
45004     } catch (...) {
45005       {
45006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45007       };
45008     }
45009   }
45010
45011 }
45012
45013
45014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45015   int jresult ;
45016   Dali::FittingMode::Type result;
45017
45018   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45019   jresult = (int)result;
45020   return jresult;
45021 }
45022
45023
45024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45025   int jresult ;
45026   Dali::SamplingMode::Type result;
45027
45028   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45029   jresult = (int)result;
45030   return jresult;
45031 }
45032
45033
45034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45035   void * jresult ;
45036   Dali::BufferImage *result = 0 ;
45037
45038   {
45039     try {
45040       result = (Dali::BufferImage *)new Dali::BufferImage();
45041     } catch (std::out_of_range& e) {
45042       {
45043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45044       };
45045     } catch (std::exception& e) {
45046       {
45047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45048       };
45049     } catch (Dali::DaliException e) {
45050       {
45051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45052       };
45053     } catch (...) {
45054       {
45055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45056       };
45057     }
45058   }
45059
45060   jresult = (void *)result;
45061   return jresult;
45062 }
45063
45064
45065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45066   void * jresult ;
45067   unsigned int arg1 ;
45068   unsigned int arg2 ;
45069   Dali::Pixel::Format arg3 ;
45070   Dali::BufferImage result;
45071
45072   arg1 = (unsigned int)jarg1;
45073   arg2 = (unsigned int)jarg2;
45074   arg3 = (Dali::Pixel::Format)jarg3;
45075   {
45076     try {
45077       result = Dali::BufferImage::New(arg1,arg2,arg3);
45078     } catch (std::out_of_range& e) {
45079       {
45080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45081       };
45082     } catch (std::exception& e) {
45083       {
45084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45085       };
45086     } catch (Dali::DaliException e) {
45087       {
45088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45089       };
45090     } catch (...) {
45091       {
45092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45093       };
45094     }
45095   }
45096
45097   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45098   return jresult;
45099 }
45100
45101
45102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45103   void * jresult ;
45104   unsigned int arg1 ;
45105   unsigned int arg2 ;
45106   Dali::BufferImage result;
45107
45108   arg1 = (unsigned int)jarg1;
45109   arg2 = (unsigned int)jarg2;
45110   {
45111     try {
45112       result = Dali::BufferImage::New(arg1,arg2);
45113     } catch (std::out_of_range& e) {
45114       {
45115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45116       };
45117     } catch (std::exception& e) {
45118       {
45119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45120       };
45121     } catch (Dali::DaliException e) {
45122       {
45123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45124       };
45125     } catch (...) {
45126       {
45127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45128       };
45129     }
45130   }
45131
45132   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45133   return jresult;
45134 }
45135
45136
45137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45138   void * jresult ;
45139   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45140   unsigned int arg2 ;
45141   unsigned int arg3 ;
45142   Dali::Pixel::Format arg4 ;
45143   unsigned int arg5 ;
45144   Dali::BufferImage result;
45145
45146   arg1 = jarg1;
45147   arg2 = (unsigned int)jarg2;
45148   arg3 = (unsigned int)jarg3;
45149   arg4 = (Dali::Pixel::Format)jarg4;
45150   arg5 = (unsigned int)jarg5;
45151   {
45152     try {
45153       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45154     } catch (std::out_of_range& e) {
45155       {
45156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45157       };
45158     } catch (std::exception& e) {
45159       {
45160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45161       };
45162     } catch (Dali::DaliException e) {
45163       {
45164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45165       };
45166     } catch (...) {
45167       {
45168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45169       };
45170     }
45171   }
45172
45173   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45174
45175
45176   return jresult;
45177 }
45178
45179
45180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45181   void * jresult ;
45182   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45183   unsigned int arg2 ;
45184   unsigned int arg3 ;
45185   Dali::Pixel::Format arg4 ;
45186   Dali::BufferImage result;
45187
45188   arg1 = jarg1;
45189   arg2 = (unsigned int)jarg2;
45190   arg3 = (unsigned int)jarg3;
45191   arg4 = (Dali::Pixel::Format)jarg4;
45192   {
45193     try {
45194       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45195     } catch (std::out_of_range& e) {
45196       {
45197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45198       };
45199     } catch (std::exception& e) {
45200       {
45201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45202       };
45203     } catch (Dali::DaliException e) {
45204       {
45205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45206       };
45207     } catch (...) {
45208       {
45209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45210       };
45211     }
45212   }
45213
45214   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45215
45216
45217   return jresult;
45218 }
45219
45220
45221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45222   void * jresult ;
45223   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45224   unsigned int arg2 ;
45225   unsigned int arg3 ;
45226   Dali::BufferImage result;
45227
45228   arg1 = jarg1;
45229   arg2 = (unsigned int)jarg2;
45230   arg3 = (unsigned int)jarg3;
45231   {
45232     try {
45233       result = Dali::BufferImage::New(arg1,arg2,arg3);
45234     } catch (std::out_of_range& e) {
45235       {
45236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45237       };
45238     } catch (std::exception& e) {
45239       {
45240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45241       };
45242     } catch (Dali::DaliException e) {
45243       {
45244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45245       };
45246     } catch (...) {
45247       {
45248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45249       };
45250     }
45251   }
45252
45253   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45254
45255
45256   return jresult;
45257 }
45258
45259
45260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45261   void * jresult ;
45262   Dali::BaseHandle arg1 ;
45263   Dali::BaseHandle *argp1 ;
45264   Dali::BufferImage result;
45265
45266   argp1 = (Dali::BaseHandle *)jarg1;
45267   if (!argp1) {
45268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45269     return 0;
45270   }
45271   arg1 = *argp1;
45272   {
45273     try {
45274       result = Dali::BufferImage::DownCast(arg1);
45275     } catch (std::out_of_range& e) {
45276       {
45277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45278       };
45279     } catch (std::exception& e) {
45280       {
45281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45282       };
45283     } catch (Dali::DaliException e) {
45284       {
45285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45286       };
45287     } catch (...) {
45288       {
45289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45290       };
45291     }
45292   }
45293
45294   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45295   return jresult;
45296 }
45297
45298
45299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45300   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45301
45302   arg1 = (Dali::BufferImage *)jarg1;
45303   {
45304     try {
45305       delete arg1;
45306     } catch (std::out_of_range& e) {
45307       {
45308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45309       };
45310     } catch (std::exception& e) {
45311       {
45312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45313       };
45314     } catch (Dali::DaliException e) {
45315       {
45316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45317       };
45318     } catch (...) {
45319       {
45320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45321       };
45322     }
45323   }
45324
45325 }
45326
45327
45328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45329   void * jresult ;
45330   Dali::BufferImage *arg1 = 0 ;
45331   Dali::BufferImage *result = 0 ;
45332
45333   arg1 = (Dali::BufferImage *)jarg1;
45334   if (!arg1) {
45335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45336     return 0;
45337   }
45338   {
45339     try {
45340       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45341     } catch (std::out_of_range& e) {
45342       {
45343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45344       };
45345     } catch (std::exception& e) {
45346       {
45347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45348       };
45349     } catch (Dali::DaliException e) {
45350       {
45351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45352       };
45353     } catch (...) {
45354       {
45355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45356       };
45357     }
45358   }
45359
45360   jresult = (void *)result;
45361   return jresult;
45362 }
45363
45364
45365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45366   void * jresult ;
45367   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45368   Dali::BufferImage *arg2 = 0 ;
45369   Dali::BufferImage *result = 0 ;
45370
45371   arg1 = (Dali::BufferImage *)jarg1;
45372   arg2 = (Dali::BufferImage *)jarg2;
45373   if (!arg2) {
45374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45375     return 0;
45376   }
45377   {
45378     try {
45379       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45380     } catch (std::out_of_range& e) {
45381       {
45382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45383       };
45384     } catch (std::exception& e) {
45385       {
45386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45387       };
45388     } catch (Dali::DaliException e) {
45389       {
45390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45391       };
45392     } catch (...) {
45393       {
45394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45395       };
45396     }
45397   }
45398
45399   jresult = (void *)result;
45400   return jresult;
45401 }
45402
45403
45404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45405   void * jresult ;
45406   Dali::BufferImage result;
45407
45408   {
45409     try {
45410       result = Dali::BufferImage::WHITE();
45411     } catch (std::out_of_range& e) {
45412       {
45413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45414       };
45415     } catch (std::exception& e) {
45416       {
45417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45418       };
45419     } catch (Dali::DaliException e) {
45420       {
45421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45422       };
45423     } catch (...) {
45424       {
45425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45426       };
45427     }
45428   }
45429
45430   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45431   return jresult;
45432 }
45433
45434
45435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45436   void * jresult ;
45437   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45438   Dali::PixelBuffer *result = 0 ;
45439
45440   arg1 = (Dali::BufferImage *)jarg1;
45441   {
45442     try {
45443       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45444     } catch (std::out_of_range& e) {
45445       {
45446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45447       };
45448     } catch (std::exception& e) {
45449       {
45450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45451       };
45452     } catch (Dali::DaliException e) {
45453       {
45454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45455       };
45456     } catch (...) {
45457       {
45458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45459       };
45460     }
45461   }
45462
45463   jresult = (void *)result;
45464   return jresult;
45465 }
45466
45467
45468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45469   unsigned int jresult ;
45470   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45471   unsigned int result;
45472
45473   arg1 = (Dali::BufferImage *)jarg1;
45474   {
45475     try {
45476       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45477     } catch (std::out_of_range& e) {
45478       {
45479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45480       };
45481     } catch (std::exception& e) {
45482       {
45483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45484       };
45485     } catch (Dali::DaliException e) {
45486       {
45487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45488       };
45489     } catch (...) {
45490       {
45491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45492       };
45493     }
45494   }
45495
45496   jresult = result;
45497   return jresult;
45498 }
45499
45500
45501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45502   unsigned int jresult ;
45503   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45504   unsigned int result;
45505
45506   arg1 = (Dali::BufferImage *)jarg1;
45507   {
45508     try {
45509       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45510     } catch (std::out_of_range& e) {
45511       {
45512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45513       };
45514     } catch (std::exception& e) {
45515       {
45516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45517       };
45518     } catch (Dali::DaliException e) {
45519       {
45520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45521       };
45522     } catch (...) {
45523       {
45524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45525       };
45526     }
45527   }
45528
45529   jresult = result;
45530   return jresult;
45531 }
45532
45533
45534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45535   int jresult ;
45536   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45537   Dali::Pixel::Format result;
45538
45539   arg1 = (Dali::BufferImage *)jarg1;
45540   {
45541     try {
45542       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45543     } catch (std::out_of_range& e) {
45544       {
45545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45546       };
45547     } catch (std::exception& e) {
45548       {
45549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45550       };
45551     } catch (Dali::DaliException e) {
45552       {
45553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45554       };
45555     } catch (...) {
45556       {
45557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45558       };
45559     }
45560   }
45561
45562   jresult = (int)result;
45563   return jresult;
45564 }
45565
45566
45567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45568   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45569
45570   arg1 = (Dali::BufferImage *)jarg1;
45571   {
45572     try {
45573       (arg1)->Update();
45574     } catch (std::out_of_range& e) {
45575       {
45576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45577       };
45578     } catch (std::exception& e) {
45579       {
45580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45581       };
45582     } catch (Dali::DaliException e) {
45583       {
45584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45585       };
45586     } catch (...) {
45587       {
45588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45589       };
45590     }
45591   }
45592
45593 }
45594
45595
45596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45597   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45598   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45599   Dali::RectArea *argp2 ;
45600
45601   arg1 = (Dali::BufferImage *)jarg1;
45602   argp2 = (Dali::RectArea *)jarg2;
45603   if (!argp2) {
45604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45605     return ;
45606   }
45607   arg2 = *argp2;
45608   {
45609     try {
45610       (arg1)->Update(arg2);
45611     } catch (std::out_of_range& e) {
45612       {
45613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45614       };
45615     } catch (std::exception& e) {
45616       {
45617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45618       };
45619     } catch (Dali::DaliException e) {
45620       {
45621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45622       };
45623     } catch (...) {
45624       {
45625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45626       };
45627     }
45628   }
45629
45630 }
45631
45632
45633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45634   unsigned int jresult ;
45635   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45636   bool result;
45637
45638   arg1 = (Dali::BufferImage *)jarg1;
45639   {
45640     try {
45641       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45642     } catch (std::out_of_range& e) {
45643       {
45644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45645       };
45646     } catch (std::exception& e) {
45647       {
45648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45649       };
45650     } catch (Dali::DaliException e) {
45651       {
45652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45653       };
45654     } catch (...) {
45655       {
45656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45657       };
45658     }
45659   }
45660
45661   jresult = result;
45662   return jresult;
45663 }
45664
45665
45666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45667   void * jresult ;
45668   Dali::EncodedBufferImage *result = 0 ;
45669
45670   {
45671     try {
45672       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45673     } catch (std::out_of_range& e) {
45674       {
45675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45676       };
45677     } catch (std::exception& e) {
45678       {
45679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45680       };
45681     } catch (Dali::DaliException e) {
45682       {
45683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45684       };
45685     } catch (...) {
45686       {
45687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45688       };
45689     }
45690   }
45691
45692   jresult = (void *)result;
45693   return jresult;
45694 }
45695
45696
45697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45698   void * jresult ;
45699   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45700   std::size_t arg2 ;
45701   Dali::EncodedBufferImage result;
45702
45703   arg1 = (uint8_t *)jarg1;
45704   arg2 = (std::size_t)jarg2;
45705   {
45706     try {
45707       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45708     } catch (std::out_of_range& e) {
45709       {
45710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45711       };
45712     } catch (std::exception& e) {
45713       {
45714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45715       };
45716     } catch (Dali::DaliException e) {
45717       {
45718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45719       };
45720     } catch (...) {
45721       {
45722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45723       };
45724     }
45725   }
45726
45727   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45728   return jresult;
45729 }
45730
45731
45732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45733   void * jresult ;
45734   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45735   std::size_t arg2 ;
45736   Dali::ImageDimensions arg3 ;
45737   Dali::FittingMode::Type arg4 ;
45738   Dali::SamplingMode::Type arg5 ;
45739   bool arg6 ;
45740   Dali::ImageDimensions *argp3 ;
45741   Dali::EncodedBufferImage result;
45742
45743   arg1 = (uint8_t *)jarg1;
45744   arg2 = (std::size_t)jarg2;
45745   argp3 = (Dali::ImageDimensions *)jarg3;
45746   if (!argp3) {
45747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45748     return 0;
45749   }
45750   arg3 = *argp3;
45751   arg4 = (Dali::FittingMode::Type)jarg4;
45752   arg5 = (Dali::SamplingMode::Type)jarg5;
45753   arg6 = jarg6 ? true : false;
45754   {
45755     try {
45756       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45757     } catch (std::out_of_range& e) {
45758       {
45759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45760       };
45761     } catch (std::exception& e) {
45762       {
45763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (Dali::DaliException e) {
45766       {
45767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45768       };
45769     } catch (...) {
45770       {
45771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45772       };
45773     }
45774   }
45775
45776   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45777   return jresult;
45778 }
45779
45780
45781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45782   void * jresult ;
45783   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45784   std::size_t arg2 ;
45785   Dali::ImageDimensions arg3 ;
45786   Dali::FittingMode::Type arg4 ;
45787   Dali::SamplingMode::Type arg5 ;
45788   Dali::ImageDimensions *argp3 ;
45789   Dali::EncodedBufferImage result;
45790
45791   arg1 = (uint8_t *)jarg1;
45792   arg2 = (std::size_t)jarg2;
45793   argp3 = (Dali::ImageDimensions *)jarg3;
45794   if (!argp3) {
45795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45796     return 0;
45797   }
45798   arg3 = *argp3;
45799   arg4 = (Dali::FittingMode::Type)jarg4;
45800   arg5 = (Dali::SamplingMode::Type)jarg5;
45801   {
45802     try {
45803       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45804     } catch (std::out_of_range& e) {
45805       {
45806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45807       };
45808     } catch (std::exception& e) {
45809       {
45810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45811       };
45812     } catch (Dali::DaliException e) {
45813       {
45814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45815       };
45816     } catch (...) {
45817       {
45818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45819       };
45820     }
45821   }
45822
45823   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45824   return jresult;
45825 }
45826
45827
45828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45829   void * jresult ;
45830   Dali::BaseHandle arg1 ;
45831   Dali::BaseHandle *argp1 ;
45832   Dali::EncodedBufferImage result;
45833
45834   argp1 = (Dali::BaseHandle *)jarg1;
45835   if (!argp1) {
45836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45837     return 0;
45838   }
45839   arg1 = *argp1;
45840   {
45841     try {
45842       result = Dali::EncodedBufferImage::DownCast(arg1);
45843     } catch (std::out_of_range& e) {
45844       {
45845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45846       };
45847     } catch (std::exception& e) {
45848       {
45849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45850       };
45851     } catch (Dali::DaliException e) {
45852       {
45853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45854       };
45855     } catch (...) {
45856       {
45857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45858       };
45859     }
45860   }
45861
45862   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45863   return jresult;
45864 }
45865
45866
45867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45868   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45869
45870   arg1 = (Dali::EncodedBufferImage *)jarg1;
45871   {
45872     try {
45873       delete arg1;
45874     } catch (std::out_of_range& e) {
45875       {
45876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45877       };
45878     } catch (std::exception& e) {
45879       {
45880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45881       };
45882     } catch (Dali::DaliException e) {
45883       {
45884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45885       };
45886     } catch (...) {
45887       {
45888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45889       };
45890     }
45891   }
45892
45893 }
45894
45895
45896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45897   void * jresult ;
45898   Dali::EncodedBufferImage *arg1 = 0 ;
45899   Dali::EncodedBufferImage *result = 0 ;
45900
45901   arg1 = (Dali::EncodedBufferImage *)jarg1;
45902   if (!arg1) {
45903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45904     return 0;
45905   }
45906   {
45907     try {
45908       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45909     } catch (std::out_of_range& e) {
45910       {
45911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45912       };
45913     } catch (std::exception& e) {
45914       {
45915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45916       };
45917     } catch (Dali::DaliException e) {
45918       {
45919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45920       };
45921     } catch (...) {
45922       {
45923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45924       };
45925     }
45926   }
45927
45928   jresult = (void *)result;
45929   return jresult;
45930 }
45931
45932
45933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45934   void * jresult ;
45935   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45936   Dali::EncodedBufferImage *arg2 = 0 ;
45937   Dali::EncodedBufferImage *result = 0 ;
45938
45939   arg1 = (Dali::EncodedBufferImage *)jarg1;
45940   arg2 = (Dali::EncodedBufferImage *)jarg2;
45941   if (!arg2) {
45942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45943     return 0;
45944   }
45945   {
45946     try {
45947       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45948     } catch (std::out_of_range& e) {
45949       {
45950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45951       };
45952     } catch (std::exception& e) {
45953       {
45954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45955       };
45956     } catch (Dali::DaliException e) {
45957       {
45958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45959       };
45960     } catch (...) {
45961       {
45962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45963       };
45964     }
45965   }
45966
45967   jresult = (void *)result;
45968   return jresult;
45969 }
45970
45971
45972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45973   void * jresult ;
45974   Dali::NativeImage *result = 0 ;
45975
45976   {
45977     try {
45978       result = (Dali::NativeImage *)new Dali::NativeImage();
45979     } catch (std::out_of_range& e) {
45980       {
45981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45982       };
45983     } catch (std::exception& e) {
45984       {
45985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45986       };
45987     } catch (Dali::DaliException e) {
45988       {
45989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45990       };
45991     } catch (...) {
45992       {
45993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45994       };
45995     }
45996   }
45997
45998   jresult = (void *)result;
45999   return jresult;
46000 }
46001
46002
46003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46004   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46005
46006   arg1 = (Dali::NativeImage *)jarg1;
46007   {
46008     try {
46009       delete arg1;
46010     } catch (std::out_of_range& e) {
46011       {
46012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46013       };
46014     } catch (std::exception& e) {
46015       {
46016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46017       };
46018     } catch (Dali::DaliException e) {
46019       {
46020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46021       };
46022     } catch (...) {
46023       {
46024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46025       };
46026     }
46027   }
46028
46029 }
46030
46031
46032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46033   void * jresult ;
46034   Dali::NativeImage *arg1 = 0 ;
46035   Dali::NativeImage *result = 0 ;
46036
46037   arg1 = (Dali::NativeImage *)jarg1;
46038   if (!arg1) {
46039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46040     return 0;
46041   }
46042   {
46043     try {
46044       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46045     } catch (std::out_of_range& e) {
46046       {
46047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46048       };
46049     } catch (std::exception& e) {
46050       {
46051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46052       };
46053     } catch (Dali::DaliException e) {
46054       {
46055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46056       };
46057     } catch (...) {
46058       {
46059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46060       };
46061     }
46062   }
46063
46064   jresult = (void *)result;
46065   return jresult;
46066 }
46067
46068
46069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46070   void * jresult ;
46071   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46072   Dali::NativeImage *arg2 = 0 ;
46073   Dali::NativeImage *result = 0 ;
46074
46075   arg1 = (Dali::NativeImage *)jarg1;
46076   arg2 = (Dali::NativeImage *)jarg2;
46077   if (!arg2) {
46078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46079     return 0;
46080   }
46081   {
46082     try {
46083       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46084     } catch (std::out_of_range& e) {
46085       {
46086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46087       };
46088     } catch (std::exception& e) {
46089       {
46090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46091       };
46092     } catch (Dali::DaliException e) {
46093       {
46094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46095       };
46096     } catch (...) {
46097       {
46098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46099       };
46100     }
46101   }
46102
46103   jresult = (void *)result;
46104   return jresult;
46105 }
46106
46107
46108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46109   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46110
46111   arg1 = (Dali::NativeImage *)jarg1;
46112   {
46113     try {
46114       (arg1)->CreateGlTexture();
46115     } catch (std::out_of_range& e) {
46116       {
46117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46118       };
46119     } catch (std::exception& e) {
46120       {
46121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46122       };
46123     } catch (Dali::DaliException e) {
46124       {
46125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46126       };
46127     } catch (...) {
46128       {
46129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46130       };
46131     }
46132   }
46133
46134 }
46135
46136
46137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46138   void * jresult ;
46139   NativeImageInterface *arg1 = 0 ;
46140   Dali::NativeImage result;
46141
46142   arg1 = (NativeImageInterface *)jarg1;
46143   if (!arg1) {
46144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46145     return 0;
46146   }
46147   {
46148     try {
46149       result = Dali::NativeImage::New(*arg1);
46150     } catch (std::out_of_range& e) {
46151       {
46152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46153       };
46154     } catch (std::exception& e) {
46155       {
46156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46157       };
46158     } catch (Dali::DaliException e) {
46159       {
46160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46161       };
46162     } catch (...) {
46163       {
46164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46165       };
46166     }
46167   }
46168
46169   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46170   return jresult;
46171 }
46172
46173
46174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46175   void * jresult ;
46176   Dali::BaseHandle arg1 ;
46177   Dali::BaseHandle *argp1 ;
46178   Dali::NativeImage result;
46179
46180   argp1 = (Dali::BaseHandle *)jarg1;
46181   if (!argp1) {
46182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46183     return 0;
46184   }
46185   arg1 = *argp1;
46186   {
46187     try {
46188       result = Dali::NativeImage::DownCast(arg1);
46189     } catch (std::out_of_range& e) {
46190       {
46191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46192       };
46193     } catch (std::exception& e) {
46194       {
46195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46196       };
46197     } catch (Dali::DaliException e) {
46198       {
46199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46200       };
46201     } catch (...) {
46202       {
46203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46204       };
46205     }
46206   }
46207
46208   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46209   return jresult;
46210 }
46211
46212
46213 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46214   char * jresult ;
46215   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46216   char *result = 0 ;
46217
46218   arg1 = (Dali::NativeImage *)jarg1;
46219   {
46220     try {
46221       result = (char *)(arg1)->GetCustomFragmentPreFix();
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 (Dali::DaliException e) {
46231       {
46232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46233       };
46234     } catch (...) {
46235       {
46236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46237       };
46238     }
46239   }
46240
46241   jresult = SWIG_csharp_string_callback((const char *)result);
46242   return jresult;
46243 }
46244
46245
46246 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46247   char * jresult ;
46248   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46249   char *result = 0 ;
46250
46251   arg1 = (Dali::NativeImage *)jarg1;
46252   {
46253     try {
46254       result = (char *)(arg1)->GetCustomSamplerTypename();
46255     } catch (std::out_of_range& e) {
46256       {
46257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46258       };
46259     } catch (std::exception& e) {
46260       {
46261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46262       };
46263     } catch (Dali::DaliException e) {
46264       {
46265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46266       };
46267     } catch (...) {
46268       {
46269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46270       };
46271     }
46272   }
46273
46274   jresult = SWIG_csharp_string_callback((const char *)result);
46275   return jresult;
46276 }
46277
46278
46279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46280   unsigned int jresult ;
46281   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46282   bool result;
46283
46284   arg1 = (Dali::NativeImageInterface *)jarg1;
46285   {
46286     try {
46287       result = (bool)(arg1)->GlExtensionCreate();
46288     } catch (std::out_of_range& e) {
46289       {
46290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46291       };
46292     } catch (std::exception& e) {
46293       {
46294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46295       };
46296     } catch (Dali::DaliException e) {
46297       {
46298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46299       };
46300     } catch (...) {
46301       {
46302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46303       };
46304     }
46305   }
46306
46307   jresult = result;
46308   return jresult;
46309 }
46310
46311
46312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46313   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46314
46315   arg1 = (Dali::NativeImageInterface *)jarg1;
46316   {
46317     try {
46318       (arg1)->GlExtensionDestroy();
46319     } catch (std::out_of_range& e) {
46320       {
46321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46322       };
46323     } catch (std::exception& e) {
46324       {
46325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46326       };
46327     } catch (Dali::DaliException e) {
46328       {
46329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46330       };
46331     } catch (...) {
46332       {
46333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46334       };
46335     }
46336   }
46337
46338 }
46339
46340
46341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46342   unsigned int jresult ;
46343   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46344   unsigned int result;
46345
46346   arg1 = (Dali::NativeImageInterface *)jarg1;
46347   {
46348     try {
46349       result = (unsigned int)(arg1)->TargetTexture();
46350     } catch (std::out_of_range& e) {
46351       {
46352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46353       };
46354     } catch (std::exception& e) {
46355       {
46356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46357       };
46358     } catch (Dali::DaliException e) {
46359       {
46360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46361       };
46362     } catch (...) {
46363       {
46364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46365       };
46366     }
46367   }
46368
46369   jresult = result;
46370   return jresult;
46371 }
46372
46373
46374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46375   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46376
46377   arg1 = (Dali::NativeImageInterface *)jarg1;
46378   {
46379     try {
46380       (arg1)->PrepareTexture();
46381     } catch (std::out_of_range& e) {
46382       {
46383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46384       };
46385     } catch (std::exception& e) {
46386       {
46387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46388       };
46389     } catch (Dali::DaliException e) {
46390       {
46391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46392       };
46393     } catch (...) {
46394       {
46395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46396       };
46397     }
46398   }
46399
46400 }
46401
46402
46403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46404   unsigned int jresult ;
46405   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46406   unsigned int result;
46407
46408   arg1 = (Dali::NativeImageInterface *)jarg1;
46409   {
46410     try {
46411       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46412     } catch (std::out_of_range& e) {
46413       {
46414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46415       };
46416     } catch (std::exception& e) {
46417       {
46418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46419       };
46420     } catch (Dali::DaliException e) {
46421       {
46422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46423       };
46424     } catch (...) {
46425       {
46426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46427       };
46428     }
46429   }
46430
46431   jresult = result;
46432   return jresult;
46433 }
46434
46435
46436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46437   unsigned int jresult ;
46438   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46439   unsigned int result;
46440
46441   arg1 = (Dali::NativeImageInterface *)jarg1;
46442   {
46443     try {
46444       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46445     } catch (std::out_of_range& e) {
46446       {
46447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46448       };
46449     } catch (std::exception& e) {
46450       {
46451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46452       };
46453     } catch (Dali::DaliException e) {
46454       {
46455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46456       };
46457     } catch (...) {
46458       {
46459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46460       };
46461     }
46462   }
46463
46464   jresult = result;
46465   return jresult;
46466 }
46467
46468
46469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46470   unsigned int jresult ;
46471   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46472   bool result;
46473
46474   arg1 = (Dali::NativeImageInterface *)jarg1;
46475   {
46476     try {
46477       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46478     } catch (std::out_of_range& e) {
46479       {
46480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46481       };
46482     } catch (std::exception& e) {
46483       {
46484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46485       };
46486     } catch (Dali::DaliException e) {
46487       {
46488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46489       };
46490     } catch (...) {
46491       {
46492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46493       };
46494     }
46495   }
46496
46497   jresult = result;
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46503   void * jresult ;
46504   std::string *arg1 = 0 ;
46505   Dali::ImageDimensions result;
46506
46507   if (!jarg1) {
46508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46509     return 0;
46510   }
46511   std::string arg1_str(jarg1);
46512   arg1 = &arg1_str;
46513   {
46514     try {
46515       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46516     } catch (std::out_of_range& e) {
46517       {
46518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46519       };
46520     } catch (std::exception& e) {
46521       {
46522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46523       };
46524     } catch (Dali::DaliException e) {
46525       {
46526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46527       };
46528     } catch (...) {
46529       {
46530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46531       };
46532     }
46533   }
46534
46535   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46536
46537   //argout typemap for const std::string&
46538
46539   return jresult;
46540 }
46541
46542
46543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46544   void * jresult ;
46545   Dali::ResourceImage *result = 0 ;
46546
46547   {
46548     try {
46549       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46550     } catch (std::out_of_range& e) {
46551       {
46552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46553       };
46554     } catch (std::exception& e) {
46555       {
46556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46557       };
46558     } catch (Dali::DaliException e) {
46559       {
46560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46561       };
46562     } catch (...) {
46563       {
46564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46565       };
46566     }
46567   }
46568
46569   jresult = (void *)result;
46570   return jresult;
46571 }
46572
46573
46574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46575   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46576
46577   arg1 = (Dali::ResourceImage *)jarg1;
46578   {
46579     try {
46580       delete arg1;
46581     } catch (std::out_of_range& e) {
46582       {
46583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46584       };
46585     } catch (std::exception& e) {
46586       {
46587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46588       };
46589     } catch (Dali::DaliException e) {
46590       {
46591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46592       };
46593     } catch (...) {
46594       {
46595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46596       };
46597     }
46598   }
46599
46600 }
46601
46602
46603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46604   void * jresult ;
46605   Dali::ResourceImage *arg1 = 0 ;
46606   Dali::ResourceImage *result = 0 ;
46607
46608   arg1 = (Dali::ResourceImage *)jarg1;
46609   if (!arg1) {
46610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46611     return 0;
46612   }
46613   {
46614     try {
46615       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46616     } catch (std::out_of_range& e) {
46617       {
46618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46619       };
46620     } catch (std::exception& e) {
46621       {
46622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46623       };
46624     } catch (Dali::DaliException e) {
46625       {
46626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46627       };
46628     } catch (...) {
46629       {
46630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46631       };
46632     }
46633   }
46634
46635   jresult = (void *)result;
46636   return jresult;
46637 }
46638
46639
46640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46641   void * jresult ;
46642   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46643   Dali::ResourceImage *arg2 = 0 ;
46644   Dali::ResourceImage *result = 0 ;
46645
46646   arg1 = (Dali::ResourceImage *)jarg1;
46647   arg2 = (Dali::ResourceImage *)jarg2;
46648   if (!arg2) {
46649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46650     return 0;
46651   }
46652   {
46653     try {
46654       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46655     } catch (std::out_of_range& e) {
46656       {
46657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46658       };
46659     } catch (std::exception& e) {
46660       {
46661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46662       };
46663     } catch (Dali::DaliException e) {
46664       {
46665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46666       };
46667     } catch (...) {
46668       {
46669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46670       };
46671     }
46672   }
46673
46674   jresult = (void *)result;
46675   return jresult;
46676 }
46677
46678
46679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46680   void * jresult ;
46681   std::string *arg1 = 0 ;
46682   bool arg2 ;
46683   Dali::ResourceImage result;
46684
46685   if (!jarg1) {
46686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46687     return 0;
46688   }
46689   std::string arg1_str(jarg1);
46690   arg1 = &arg1_str;
46691   arg2 = jarg2 ? true : false;
46692   {
46693     try {
46694       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46695     } catch (std::out_of_range& e) {
46696       {
46697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46698       };
46699     } catch (std::exception& e) {
46700       {
46701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46702       };
46703     } catch (Dali::DaliException e) {
46704       {
46705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46706       };
46707     } catch (...) {
46708       {
46709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46710       };
46711     }
46712   }
46713
46714   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46715
46716   //argout typemap for const std::string&
46717
46718   return jresult;
46719 }
46720
46721
46722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46723   void * jresult ;
46724   std::string *arg1 = 0 ;
46725   Dali::ResourceImage result;
46726
46727   if (!jarg1) {
46728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46729     return 0;
46730   }
46731   std::string arg1_str(jarg1);
46732   arg1 = &arg1_str;
46733   {
46734     try {
46735       result = Dali::ResourceImage::New((std::string const &)*arg1);
46736     } catch (std::out_of_range& e) {
46737       {
46738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46739       };
46740     } catch (std::exception& e) {
46741       {
46742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46743       };
46744     } catch (Dali::DaliException e) {
46745       {
46746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46747       };
46748     } catch (...) {
46749       {
46750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46751       };
46752     }
46753   }
46754
46755   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46756
46757   //argout typemap for const std::string&
46758
46759   return jresult;
46760 }
46761
46762
46763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46764   void * jresult ;
46765   std::string *arg1 = 0 ;
46766   Dali::ImageDimensions arg2 ;
46767   Dali::FittingMode::Type arg3 ;
46768   Dali::SamplingMode::Type arg4 ;
46769   bool arg5 ;
46770   Dali::ImageDimensions *argp2 ;
46771   Dali::ResourceImage result;
46772
46773   if (!jarg1) {
46774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46775     return 0;
46776   }
46777   std::string arg1_str(jarg1);
46778   arg1 = &arg1_str;
46779   argp2 = (Dali::ImageDimensions *)jarg2;
46780   if (!argp2) {
46781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46782     return 0;
46783   }
46784   arg2 = *argp2;
46785   arg3 = (Dali::FittingMode::Type)jarg3;
46786   arg4 = (Dali::SamplingMode::Type)jarg4;
46787   arg5 = jarg5 ? true : false;
46788   {
46789     try {
46790       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46791     } catch (std::out_of_range& e) {
46792       {
46793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46794       };
46795     } catch (std::exception& e) {
46796       {
46797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46798       };
46799     } catch (Dali::DaliException e) {
46800       {
46801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46802       };
46803     } catch (...) {
46804       {
46805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46806       };
46807     }
46808   }
46809
46810   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46811
46812   //argout typemap for const std::string&
46813
46814   return jresult;
46815 }
46816
46817
46818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46819   void * jresult ;
46820   std::string *arg1 = 0 ;
46821   Dali::ImageDimensions arg2 ;
46822   Dali::FittingMode::Type arg3 ;
46823   Dali::SamplingMode::Type arg4 ;
46824   Dali::ImageDimensions *argp2 ;
46825   Dali::ResourceImage result;
46826
46827   if (!jarg1) {
46828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46829     return 0;
46830   }
46831   std::string arg1_str(jarg1);
46832   arg1 = &arg1_str;
46833   argp2 = (Dali::ImageDimensions *)jarg2;
46834   if (!argp2) {
46835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46836     return 0;
46837   }
46838   arg2 = *argp2;
46839   arg3 = (Dali::FittingMode::Type)jarg3;
46840   arg4 = (Dali::SamplingMode::Type)jarg4;
46841   {
46842     try {
46843       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46844     } catch (std::out_of_range& e) {
46845       {
46846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46847       };
46848     } catch (std::exception& e) {
46849       {
46850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46851       };
46852     } catch (Dali::DaliException e) {
46853       {
46854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46855       };
46856     } catch (...) {
46857       {
46858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46859       };
46860     }
46861   }
46862
46863   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46864
46865   //argout typemap for const std::string&
46866
46867   return jresult;
46868 }
46869
46870
46871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46872   void * jresult ;
46873   std::string *arg1 = 0 ;
46874   Dali::ImageDimensions arg2 ;
46875   Dali::FittingMode::Type arg3 ;
46876   Dali::ImageDimensions *argp2 ;
46877   Dali::ResourceImage result;
46878
46879   if (!jarg1) {
46880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46881     return 0;
46882   }
46883   std::string arg1_str(jarg1);
46884   arg1 = &arg1_str;
46885   argp2 = (Dali::ImageDimensions *)jarg2;
46886   if (!argp2) {
46887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46888     return 0;
46889   }
46890   arg2 = *argp2;
46891   arg3 = (Dali::FittingMode::Type)jarg3;
46892   {
46893     try {
46894       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46895     } catch (std::out_of_range& e) {
46896       {
46897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46898       };
46899     } catch (std::exception& e) {
46900       {
46901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46902       };
46903     } catch (Dali::DaliException e) {
46904       {
46905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46906       };
46907     } catch (...) {
46908       {
46909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46910       };
46911     }
46912   }
46913
46914   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46915
46916   //argout typemap for const std::string&
46917
46918   return jresult;
46919 }
46920
46921
46922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46923   void * jresult ;
46924   std::string *arg1 = 0 ;
46925   Dali::ImageDimensions arg2 ;
46926   Dali::ImageDimensions *argp2 ;
46927   Dali::ResourceImage result;
46928
46929   if (!jarg1) {
46930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46931     return 0;
46932   }
46933   std::string arg1_str(jarg1);
46934   arg1 = &arg1_str;
46935   argp2 = (Dali::ImageDimensions *)jarg2;
46936   if (!argp2) {
46937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46938     return 0;
46939   }
46940   arg2 = *argp2;
46941   {
46942     try {
46943       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46944     } catch (std::out_of_range& e) {
46945       {
46946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46947       };
46948     } catch (std::exception& e) {
46949       {
46950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46951       };
46952     } catch (Dali::DaliException e) {
46953       {
46954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46955       };
46956     } catch (...) {
46957       {
46958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46959       };
46960     }
46961   }
46962
46963   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46964
46965   //argout typemap for const std::string&
46966
46967   return jresult;
46968 }
46969
46970
46971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46972   void * jresult ;
46973   Dali::BaseHandle arg1 ;
46974   Dali::BaseHandle *argp1 ;
46975   Dali::ResourceImage result;
46976
46977   argp1 = (Dali::BaseHandle *)jarg1;
46978   if (!argp1) {
46979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46980     return 0;
46981   }
46982   arg1 = *argp1;
46983   {
46984     try {
46985       result = Dali::ResourceImage::DownCast(arg1);
46986     } catch (std::out_of_range& e) {
46987       {
46988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46989       };
46990     } catch (std::exception& e) {
46991       {
46992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46993       };
46994     } catch (Dali::DaliException e) {
46995       {
46996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46997       };
46998     } catch (...) {
46999       {
47000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47001       };
47002     }
47003   }
47004
47005   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47006   return jresult;
47007 }
47008
47009
47010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47011   int jresult ;
47012   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47013   Dali::LoadingState result;
47014
47015   arg1 = (Dali::ResourceImage *)jarg1;
47016   {
47017     try {
47018       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47019     } catch (std::out_of_range& e) {
47020       {
47021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47022       };
47023     } catch (std::exception& e) {
47024       {
47025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47026       };
47027     } catch (Dali::DaliException e) {
47028       {
47029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47030       };
47031     } catch (...) {
47032       {
47033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47034       };
47035     }
47036   }
47037
47038   jresult = (int)result;
47039   return jresult;
47040 }
47041
47042
47043 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47044   char * jresult ;
47045   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47046   std::string result;
47047
47048   arg1 = (Dali::ResourceImage *)jarg1;
47049   {
47050     try {
47051       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47052     } catch (std::out_of_range& e) {
47053       {
47054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47055       };
47056     } catch (std::exception& e) {
47057       {
47058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47059       };
47060     } catch (Dali::DaliException e) {
47061       {
47062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47063       };
47064     } catch (...) {
47065       {
47066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47067       };
47068     }
47069   }
47070
47071   jresult = SWIG_csharp_string_callback((&result)->c_str());
47072   return jresult;
47073 }
47074
47075
47076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47077   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47078
47079   arg1 = (Dali::ResourceImage *)jarg1;
47080   {
47081     try {
47082       (arg1)->Reload();
47083     } catch (std::out_of_range& e) {
47084       {
47085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47086       };
47087     } catch (std::exception& e) {
47088       {
47089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47090       };
47091     } catch (Dali::DaliException e) {
47092       {
47093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47094       };
47095     } catch (...) {
47096       {
47097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47098       };
47099     }
47100   }
47101
47102 }
47103
47104
47105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47106   void * jresult ;
47107   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47108   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47109
47110   arg1 = (Dali::ResourceImage *)jarg1;
47111   {
47112     try {
47113       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47114     } catch (std::out_of_range& e) {
47115       {
47116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47117       };
47118     } catch (std::exception& e) {
47119       {
47120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47121       };
47122     } catch (Dali::DaliException e) {
47123       {
47124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47125       };
47126     } catch (...) {
47127       {
47128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47129       };
47130     }
47131   }
47132
47133   jresult = (void *)result;
47134   return jresult;
47135 }
47136
47137
47138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47139   void * jresult ;
47140   Dali::FrameBufferImage *result = 0 ;
47141
47142   {
47143     try {
47144       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47145     } catch (std::out_of_range& e) {
47146       {
47147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47148       };
47149     } catch (std::exception& e) {
47150       {
47151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47152       };
47153     } catch (Dali::DaliException e) {
47154       {
47155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47156       };
47157     } catch (...) {
47158       {
47159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47160       };
47161     }
47162   }
47163
47164   jresult = (void *)result;
47165   return jresult;
47166 }
47167
47168
47169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47170   void * jresult ;
47171   unsigned int arg1 ;
47172   unsigned int arg2 ;
47173   Dali::Pixel::Format arg3 ;
47174   Dali::RenderBuffer::Format arg4 ;
47175   Dali::FrameBufferImage result;
47176
47177   arg1 = (unsigned int)jarg1;
47178   arg2 = (unsigned int)jarg2;
47179   arg3 = (Dali::Pixel::Format)jarg3;
47180   arg4 = (Dali::RenderBuffer::Format)jarg4;
47181   {
47182     try {
47183       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47184     } catch (std::out_of_range& e) {
47185       {
47186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47187       };
47188     } catch (std::exception& e) {
47189       {
47190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47191       };
47192     } catch (Dali::DaliException e) {
47193       {
47194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47195       };
47196     } catch (...) {
47197       {
47198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47199       };
47200     }
47201   }
47202
47203   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47204   return jresult;
47205 }
47206
47207
47208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47209   void * jresult ;
47210   unsigned int arg1 ;
47211   unsigned int arg2 ;
47212   Dali::Pixel::Format arg3 ;
47213   Dali::FrameBufferImage result;
47214
47215   arg1 = (unsigned int)jarg1;
47216   arg2 = (unsigned int)jarg2;
47217   arg3 = (Dali::Pixel::Format)jarg3;
47218   {
47219     try {
47220       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47221     } catch (std::out_of_range& e) {
47222       {
47223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47224       };
47225     } catch (std::exception& e) {
47226       {
47227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47228       };
47229     } catch (Dali::DaliException e) {
47230       {
47231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47232       };
47233     } catch (...) {
47234       {
47235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47236       };
47237     }
47238   }
47239
47240   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47241   return jresult;
47242 }
47243
47244
47245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47246   void * jresult ;
47247   unsigned int arg1 ;
47248   unsigned int arg2 ;
47249   Dali::FrameBufferImage result;
47250
47251   arg1 = (unsigned int)jarg1;
47252   arg2 = (unsigned int)jarg2;
47253   {
47254     try {
47255       result = Dali::FrameBufferImage::New(arg1,arg2);
47256     } catch (std::out_of_range& e) {
47257       {
47258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47259       };
47260     } catch (std::exception& e) {
47261       {
47262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47263       };
47264     } catch (Dali::DaliException e) {
47265       {
47266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47267       };
47268     } catch (...) {
47269       {
47270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47271       };
47272     }
47273   }
47274
47275   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47276   return jresult;
47277 }
47278
47279
47280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47281   void * jresult ;
47282   unsigned int arg1 ;
47283   Dali::FrameBufferImage result;
47284
47285   arg1 = (unsigned int)jarg1;
47286   {
47287     try {
47288       result = Dali::FrameBufferImage::New(arg1);
47289     } catch (std::out_of_range& e) {
47290       {
47291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47292       };
47293     } catch (std::exception& e) {
47294       {
47295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47296       };
47297     } catch (Dali::DaliException e) {
47298       {
47299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47300       };
47301     } catch (...) {
47302       {
47303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47304       };
47305     }
47306   }
47307
47308   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47309   return jresult;
47310 }
47311
47312
47313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47314   void * jresult ;
47315   Dali::FrameBufferImage result;
47316
47317   {
47318     try {
47319       result = Dali::FrameBufferImage::New();
47320     } catch (std::out_of_range& e) {
47321       {
47322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47323       };
47324     } catch (std::exception& e) {
47325       {
47326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47327       };
47328     } catch (Dali::DaliException e) {
47329       {
47330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47331       };
47332     } catch (...) {
47333       {
47334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47335       };
47336     }
47337   }
47338
47339   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47340   return jresult;
47341 }
47342
47343
47344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47345   void * jresult ;
47346   Dali::NativeImageInterface *arg1 = 0 ;
47347   Dali::FrameBufferImage result;
47348
47349   arg1 = (Dali::NativeImageInterface *)jarg1;
47350   if (!arg1) {
47351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47352     return 0;
47353   }
47354   {
47355     try {
47356       result = Dali::FrameBufferImage::New(*arg1);
47357     } catch (std::out_of_range& e) {
47358       {
47359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47360       };
47361     } catch (std::exception& e) {
47362       {
47363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47364       };
47365     } catch (Dali::DaliException e) {
47366       {
47367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47368       };
47369     } catch (...) {
47370       {
47371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47372       };
47373     }
47374   }
47375
47376   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47377   return jresult;
47378 }
47379
47380
47381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47382   void * jresult ;
47383   Dali::BaseHandle arg1 ;
47384   Dali::BaseHandle *argp1 ;
47385   Dali::FrameBufferImage result;
47386
47387   argp1 = (Dali::BaseHandle *)jarg1;
47388   if (!argp1) {
47389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47390     return 0;
47391   }
47392   arg1 = *argp1;
47393   {
47394     try {
47395       result = Dali::FrameBufferImage::DownCast(arg1);
47396     } catch (std::out_of_range& e) {
47397       {
47398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47399       };
47400     } catch (std::exception& e) {
47401       {
47402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47403       };
47404     } catch (Dali::DaliException e) {
47405       {
47406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47407       };
47408     } catch (...) {
47409       {
47410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47411       };
47412     }
47413   }
47414
47415   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47416   return jresult;
47417 }
47418
47419
47420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47421   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47422
47423   arg1 = (Dali::FrameBufferImage *)jarg1;
47424   {
47425     try {
47426       delete arg1;
47427     } catch (std::out_of_range& e) {
47428       {
47429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47430       };
47431     } catch (std::exception& e) {
47432       {
47433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47434       };
47435     } catch (Dali::DaliException e) {
47436       {
47437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47438       };
47439     } catch (...) {
47440       {
47441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47442       };
47443     }
47444   }
47445
47446 }
47447
47448
47449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47450   void * jresult ;
47451   Dali::FrameBufferImage *arg1 = 0 ;
47452   Dali::FrameBufferImage *result = 0 ;
47453
47454   arg1 = (Dali::FrameBufferImage *)jarg1;
47455   if (!arg1) {
47456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47457     return 0;
47458   }
47459   {
47460     try {
47461       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47462     } catch (std::out_of_range& e) {
47463       {
47464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47465       };
47466     } catch (std::exception& e) {
47467       {
47468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47469       };
47470     } catch (Dali::DaliException e) {
47471       {
47472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47473       };
47474     } catch (...) {
47475       {
47476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47477       };
47478     }
47479   }
47480
47481   jresult = (void *)result;
47482   return jresult;
47483 }
47484
47485
47486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47487   void * jresult ;
47488   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47489   Dali::FrameBufferImage *arg2 = 0 ;
47490   Dali::FrameBufferImage *result = 0 ;
47491
47492   arg1 = (Dali::FrameBufferImage *)jarg1;
47493   arg2 = (Dali::FrameBufferImage *)jarg2;
47494   if (!arg2) {
47495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47496     return 0;
47497   }
47498   {
47499     try {
47500       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47501     } catch (std::out_of_range& e) {
47502       {
47503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47504       };
47505     } catch (std::exception& e) {
47506       {
47507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47508       };
47509     } catch (Dali::DaliException e) {
47510       {
47511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47512       };
47513     } catch (...) {
47514       {
47515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47516       };
47517     }
47518   }
47519
47520   jresult = (void *)result;
47521   return jresult;
47522 }
47523
47524
47525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47526   void * jresult ;
47527   Dali::NinePatchImage *result = 0 ;
47528
47529   {
47530     try {
47531       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47532     } catch (std::out_of_range& e) {
47533       {
47534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47535       };
47536     } catch (std::exception& e) {
47537       {
47538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47539       };
47540     } catch (Dali::DaliException e) {
47541       {
47542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47543       };
47544     } catch (...) {
47545       {
47546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47547       };
47548     }
47549   }
47550
47551   jresult = (void *)result;
47552   return jresult;
47553 }
47554
47555
47556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47557   void * jresult ;
47558   std::string *arg1 = 0 ;
47559   Dali::NinePatchImage result;
47560
47561   if (!jarg1) {
47562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47563     return 0;
47564   }
47565   std::string arg1_str(jarg1);
47566   arg1 = &arg1_str;
47567   {
47568     try {
47569       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47570     } catch (std::out_of_range& e) {
47571       {
47572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47573       };
47574     } catch (std::exception& e) {
47575       {
47576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47577       };
47578     } catch (Dali::DaliException e) {
47579       {
47580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47581       };
47582     } catch (...) {
47583       {
47584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47585       };
47586     }
47587   }
47588
47589   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47590
47591   //argout typemap for const std::string&
47592
47593   return jresult;
47594 }
47595
47596
47597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47598   void * jresult ;
47599   Dali::BaseHandle arg1 ;
47600   Dali::BaseHandle *argp1 ;
47601   Dali::NinePatchImage result;
47602
47603   argp1 = (Dali::BaseHandle *)jarg1;
47604   if (!argp1) {
47605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47606     return 0;
47607   }
47608   arg1 = *argp1;
47609   {
47610     try {
47611       result = Dali::NinePatchImage::DownCast(arg1);
47612     } catch (std::out_of_range& e) {
47613       {
47614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47615       };
47616     } catch (std::exception& e) {
47617       {
47618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47619       };
47620     } catch (Dali::DaliException e) {
47621       {
47622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47623       };
47624     } catch (...) {
47625       {
47626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47627       };
47628     }
47629   }
47630
47631   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47632   return jresult;
47633 }
47634
47635
47636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47637   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47638
47639   arg1 = (Dali::NinePatchImage *)jarg1;
47640   {
47641     try {
47642       delete arg1;
47643     } catch (std::out_of_range& e) {
47644       {
47645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47646       };
47647     } catch (std::exception& e) {
47648       {
47649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47650       };
47651     } catch (Dali::DaliException e) {
47652       {
47653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47654       };
47655     } catch (...) {
47656       {
47657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47658       };
47659     }
47660   }
47661
47662 }
47663
47664
47665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47666   void * jresult ;
47667   Dali::NinePatchImage *arg1 = 0 ;
47668   Dali::NinePatchImage *result = 0 ;
47669
47670   arg1 = (Dali::NinePatchImage *)jarg1;
47671   if (!arg1) {
47672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47673     return 0;
47674   }
47675   {
47676     try {
47677       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47678     } catch (std::out_of_range& e) {
47679       {
47680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47681       };
47682     } catch (std::exception& e) {
47683       {
47684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47685       };
47686     } catch (Dali::DaliException e) {
47687       {
47688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47689       };
47690     } catch (...) {
47691       {
47692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47693       };
47694     }
47695   }
47696
47697   jresult = (void *)result;
47698   return jresult;
47699 }
47700
47701
47702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47703   void * jresult ;
47704   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47705   Dali::NinePatchImage *arg2 = 0 ;
47706   Dali::NinePatchImage *result = 0 ;
47707
47708   arg1 = (Dali::NinePatchImage *)jarg1;
47709   arg2 = (Dali::NinePatchImage *)jarg2;
47710   if (!arg2) {
47711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47712     return 0;
47713   }
47714   {
47715     try {
47716       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47717     } catch (std::out_of_range& e) {
47718       {
47719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47720       };
47721     } catch (std::exception& e) {
47722       {
47723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47724       };
47725     } catch (Dali::DaliException e) {
47726       {
47727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47728       };
47729     } catch (...) {
47730       {
47731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47732       };
47733     }
47734   }
47735
47736   jresult = (void *)result;
47737   return jresult;
47738 }
47739
47740
47741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47742   void * jresult ;
47743   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47744   Dali::Vector4 result;
47745
47746   arg1 = (Dali::NinePatchImage *)jarg1;
47747   {
47748     try {
47749       result = (arg1)->GetStretchBorders();
47750     } catch (std::out_of_range& e) {
47751       {
47752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47753       };
47754     } catch (std::exception& e) {
47755       {
47756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47757       };
47758     } catch (Dali::DaliException e) {
47759       {
47760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47761       };
47762     } catch (...) {
47763       {
47764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47765       };
47766     }
47767   }
47768
47769   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47770   return jresult;
47771 }
47772
47773
47774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47775   void * jresult ;
47776   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47777   Dali::NinePatchImage::StretchRanges *result = 0 ;
47778
47779   arg1 = (Dali::NinePatchImage *)jarg1;
47780   {
47781     try {
47782       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47783     } catch (std::out_of_range& e) {
47784       {
47785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47786       };
47787     } catch (std::exception& e) {
47788       {
47789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47790       };
47791     } catch (Dali::DaliException e) {
47792       {
47793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47794       };
47795     } catch (...) {
47796       {
47797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47798       };
47799     }
47800   }
47801
47802   jresult = (void *)result;
47803   return jresult;
47804 }
47805
47806
47807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47808   void * jresult ;
47809   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47810   Dali::NinePatchImage::StretchRanges *result = 0 ;
47811
47812   arg1 = (Dali::NinePatchImage *)jarg1;
47813   {
47814     try {
47815       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47816     } catch (std::out_of_range& e) {
47817       {
47818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47819       };
47820     } catch (std::exception& e) {
47821       {
47822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47823       };
47824     } catch (Dali::DaliException e) {
47825       {
47826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47827       };
47828     } catch (...) {
47829       {
47830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47831       };
47832     }
47833   }
47834
47835   jresult = (void *)result;
47836   return jresult;
47837 }
47838
47839
47840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47841   void * jresult ;
47842   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47843   Dali::Rect< int > result;
47844
47845   arg1 = (Dali::NinePatchImage *)jarg1;
47846   {
47847     try {
47848       result = (arg1)->GetChildRectangle();
47849     } catch (std::out_of_range& e) {
47850       {
47851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47852       };
47853     } catch (std::exception& e) {
47854       {
47855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47856       };
47857     } catch (Dali::DaliException e) {
47858       {
47859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47860       };
47861     } catch (...) {
47862       {
47863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47864       };
47865     }
47866   }
47867
47868   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47869   return jresult;
47870 }
47871
47872
47873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47874   void * jresult ;
47875   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47876   Dali::BufferImage result;
47877
47878   arg1 = (Dali::NinePatchImage *)jarg1;
47879   {
47880     try {
47881       result = (arg1)->CreateCroppedBufferImage();
47882     } catch (std::out_of_range& e) {
47883       {
47884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47885       };
47886     } catch (std::exception& e) {
47887       {
47888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47889       };
47890     } catch (Dali::DaliException e) {
47891       {
47892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47893       };
47894     } catch (...) {
47895       {
47896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47897       };
47898     }
47899   }
47900
47901   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47902   return jresult;
47903 }
47904
47905
47906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47907   unsigned int jresult ;
47908   std::string *arg1 = 0 ;
47909   bool result;
47910
47911   if (!jarg1) {
47912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47913     return 0;
47914   }
47915   std::string arg1_str(jarg1);
47916   arg1 = &arg1_str;
47917   {
47918     try {
47919       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47920     } catch (std::out_of_range& e) {
47921       {
47922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47923       };
47924     } catch (std::exception& e) {
47925       {
47926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47927       };
47928     } catch (Dali::DaliException e) {
47929       {
47930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47931       };
47932     } catch (...) {
47933       {
47934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47935       };
47936     }
47937   }
47938
47939   jresult = result;
47940
47941   //argout typemap for const std::string&
47942
47943   return jresult;
47944 }
47945
47946
47947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47948   int jresult ;
47949   int result;
47950
47951   result = (int)Dali::CameraActor::Property::TYPE;
47952   jresult = (int)result;
47953   return jresult;
47954 }
47955
47956
47957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47958   int jresult ;
47959   int result;
47960
47961   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47962   jresult = (int)result;
47963   return jresult;
47964 }
47965
47966
47967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47968   int jresult ;
47969   int result;
47970
47971   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47972   jresult = (int)result;
47973   return jresult;
47974 }
47975
47976
47977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47978   int jresult ;
47979   int result;
47980
47981   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47982   jresult = (int)result;
47983   return jresult;
47984 }
47985
47986
47987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47988   int jresult ;
47989   int result;
47990
47991   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47992   jresult = (int)result;
47993   return jresult;
47994 }
47995
47996
47997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47998   int jresult ;
47999   int result;
48000
48001   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48002   jresult = (int)result;
48003   return jresult;
48004 }
48005
48006
48007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48008   int jresult ;
48009   int result;
48010
48011   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48012   jresult = (int)result;
48013   return jresult;
48014 }
48015
48016
48017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48018   int jresult ;
48019   int result;
48020
48021   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48022   jresult = (int)result;
48023   return jresult;
48024 }
48025
48026
48027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48028   int jresult ;
48029   int result;
48030
48031   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48032   jresult = (int)result;
48033   return jresult;
48034 }
48035
48036
48037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48038   int jresult ;
48039   int result;
48040
48041   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48042   jresult = (int)result;
48043   return jresult;
48044 }
48045
48046
48047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48048   int jresult ;
48049   int result;
48050
48051   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48052   jresult = (int)result;
48053   return jresult;
48054 }
48055
48056
48057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48058   int jresult ;
48059   int result;
48060
48061   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48062   jresult = (int)result;
48063   return jresult;
48064 }
48065
48066
48067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48068   int jresult ;
48069   int result;
48070
48071   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48072   jresult = (int)result;
48073   return jresult;
48074 }
48075
48076
48077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48078   int jresult ;
48079   int result;
48080
48081   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48082   jresult = (int)result;
48083   return jresult;
48084 }
48085
48086
48087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48088   void * jresult ;
48089   Dali::CameraActor::Property *result = 0 ;
48090
48091   {
48092     try {
48093       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48094     } catch (std::out_of_range& e) {
48095       {
48096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48097       };
48098     } catch (std::exception& e) {
48099       {
48100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48101       };
48102     } catch (Dali::DaliException e) {
48103       {
48104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48105       };
48106     } catch (...) {
48107       {
48108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48109       };
48110     }
48111   }
48112
48113   jresult = (void *)result;
48114   return jresult;
48115 }
48116
48117
48118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48119   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48120
48121   arg1 = (Dali::CameraActor::Property *)jarg1;
48122   {
48123     try {
48124       delete arg1;
48125     } catch (std::out_of_range& e) {
48126       {
48127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48128       };
48129     } catch (std::exception& e) {
48130       {
48131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48132       };
48133     } catch (Dali::DaliException e) {
48134       {
48135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48136       };
48137     } catch (...) {
48138       {
48139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48140       };
48141     }
48142   }
48143
48144 }
48145
48146
48147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48148   void * jresult ;
48149   Dali::CameraActor *result = 0 ;
48150
48151   {
48152     try {
48153       result = (Dali::CameraActor *)new Dali::CameraActor();
48154     } catch (std::out_of_range& e) {
48155       {
48156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48157       };
48158     } catch (std::exception& e) {
48159       {
48160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48161       };
48162     } catch (Dali::DaliException e) {
48163       {
48164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48165       };
48166     } catch (...) {
48167       {
48168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48169       };
48170     }
48171   }
48172
48173   jresult = (void *)result;
48174   return jresult;
48175 }
48176
48177
48178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48179   void * jresult ;
48180   Dali::CameraActor result;
48181
48182   {
48183     try {
48184       result = Dali::CameraActor::New();
48185     } catch (std::out_of_range& e) {
48186       {
48187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48188       };
48189     } catch (std::exception& e) {
48190       {
48191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48192       };
48193     } catch (Dali::DaliException e) {
48194       {
48195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48196       };
48197     } catch (...) {
48198       {
48199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48200       };
48201     }
48202   }
48203
48204   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48205   return jresult;
48206 }
48207
48208
48209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48210   void * jresult ;
48211   Dali::Size *arg1 = 0 ;
48212   Dali::CameraActor result;
48213
48214   arg1 = (Dali::Size *)jarg1;
48215   if (!arg1) {
48216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48217     return 0;
48218   }
48219   {
48220     try {
48221       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48222     } catch (std::out_of_range& e) {
48223       {
48224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48225       };
48226     } catch (std::exception& e) {
48227       {
48228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48229       };
48230     } catch (Dali::DaliException e) {
48231       {
48232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48233       };
48234     } catch (...) {
48235       {
48236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48237       };
48238     }
48239   }
48240
48241   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48242   return jresult;
48243 }
48244
48245
48246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48247   void * jresult ;
48248   Dali::BaseHandle arg1 ;
48249   Dali::BaseHandle *argp1 ;
48250   Dali::CameraActor result;
48251
48252   argp1 = (Dali::BaseHandle *)jarg1;
48253   if (!argp1) {
48254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48255     return 0;
48256   }
48257   arg1 = *argp1;
48258   {
48259     try {
48260       result = Dali::CameraActor::DownCast(arg1);
48261     } catch (std::out_of_range& e) {
48262       {
48263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48264       };
48265     } catch (std::exception& e) {
48266       {
48267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48268       };
48269     } catch (Dali::DaliException e) {
48270       {
48271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48272       };
48273     } catch (...) {
48274       {
48275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48276       };
48277     }
48278   }
48279
48280   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48281   return jresult;
48282 }
48283
48284
48285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48286   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48287
48288   arg1 = (Dali::CameraActor *)jarg1;
48289   {
48290     try {
48291       delete arg1;
48292     } catch (std::out_of_range& e) {
48293       {
48294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48295       };
48296     } catch (std::exception& e) {
48297       {
48298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48299       };
48300     } catch (Dali::DaliException e) {
48301       {
48302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48303       };
48304     } catch (...) {
48305       {
48306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48307       };
48308     }
48309   }
48310
48311 }
48312
48313
48314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48315   void * jresult ;
48316   Dali::CameraActor *arg1 = 0 ;
48317   Dali::CameraActor *result = 0 ;
48318
48319   arg1 = (Dali::CameraActor *)jarg1;
48320   if (!arg1) {
48321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48322     return 0;
48323   }
48324   {
48325     try {
48326       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48327     } catch (std::out_of_range& e) {
48328       {
48329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48330       };
48331     } catch (std::exception& e) {
48332       {
48333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48334       };
48335     } catch (Dali::DaliException e) {
48336       {
48337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48338       };
48339     } catch (...) {
48340       {
48341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48342       };
48343     }
48344   }
48345
48346   jresult = (void *)result;
48347   return jresult;
48348 }
48349
48350
48351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48352   void * jresult ;
48353   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48354   Dali::CameraActor *arg2 = 0 ;
48355   Dali::CameraActor *result = 0 ;
48356
48357   arg1 = (Dali::CameraActor *)jarg1;
48358   arg2 = (Dali::CameraActor *)jarg2;
48359   if (!arg2) {
48360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48361     return 0;
48362   }
48363   {
48364     try {
48365       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48366     } catch (std::out_of_range& e) {
48367       {
48368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48369       };
48370     } catch (std::exception& e) {
48371       {
48372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48373       };
48374     } catch (Dali::DaliException e) {
48375       {
48376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48377       };
48378     } catch (...) {
48379       {
48380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48381       };
48382     }
48383   }
48384
48385   jresult = (void *)result;
48386   return jresult;
48387 }
48388
48389
48390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48391   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48392   Dali::Camera::Type arg2 ;
48393
48394   arg1 = (Dali::CameraActor *)jarg1;
48395   arg2 = (Dali::Camera::Type)jarg2;
48396   {
48397     try {
48398       (arg1)->SetType(arg2);
48399     } catch (std::out_of_range& e) {
48400       {
48401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48402       };
48403     } catch (std::exception& e) {
48404       {
48405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48406       };
48407     } catch (Dali::DaliException e) {
48408       {
48409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48410       };
48411     } catch (...) {
48412       {
48413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48414       };
48415     }
48416   }
48417
48418 }
48419
48420
48421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48422   int jresult ;
48423   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48424   Dali::Camera::Type result;
48425
48426   arg1 = (Dali::CameraActor *)jarg1;
48427   {
48428     try {
48429       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48430     } catch (std::out_of_range& e) {
48431       {
48432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48433       };
48434     } catch (std::exception& e) {
48435       {
48436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48437       };
48438     } catch (Dali::DaliException e) {
48439       {
48440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48441       };
48442     } catch (...) {
48443       {
48444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48445       };
48446     }
48447   }
48448
48449   jresult = (int)result;
48450   return jresult;
48451 }
48452
48453
48454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48455   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48456   Dali::Camera::ProjectionMode arg2 ;
48457
48458   arg1 = (Dali::CameraActor *)jarg1;
48459   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48460   {
48461     try {
48462       (arg1)->SetProjectionMode(arg2);
48463     } catch (std::out_of_range& e) {
48464       {
48465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48466       };
48467     } catch (std::exception& e) {
48468       {
48469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48470       };
48471     } catch (Dali::DaliException e) {
48472       {
48473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48474       };
48475     } catch (...) {
48476       {
48477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48478       };
48479     }
48480   }
48481
48482 }
48483
48484
48485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48486   int jresult ;
48487   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48488   Dali::Camera::ProjectionMode result;
48489
48490   arg1 = (Dali::CameraActor *)jarg1;
48491   {
48492     try {
48493       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48494     } catch (std::out_of_range& e) {
48495       {
48496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48497       };
48498     } catch (std::exception& e) {
48499       {
48500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48501       };
48502     } catch (Dali::DaliException e) {
48503       {
48504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48505       };
48506     } catch (...) {
48507       {
48508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48509       };
48510     }
48511   }
48512
48513   jresult = (int)result;
48514   return jresult;
48515 }
48516
48517
48518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48519   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48520   float arg2 ;
48521
48522   arg1 = (Dali::CameraActor *)jarg1;
48523   arg2 = (float)jarg2;
48524   {
48525     try {
48526       (arg1)->SetFieldOfView(arg2);
48527     } catch (std::out_of_range& e) {
48528       {
48529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48530       };
48531     } catch (std::exception& e) {
48532       {
48533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48534       };
48535     } catch (Dali::DaliException e) {
48536       {
48537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48538       };
48539     } catch (...) {
48540       {
48541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48542       };
48543     }
48544   }
48545
48546 }
48547
48548
48549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48550   float jresult ;
48551   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48552   float result;
48553
48554   arg1 = (Dali::CameraActor *)jarg1;
48555   {
48556     try {
48557       result = (float)(arg1)->GetFieldOfView();
48558     } catch (std::out_of_range& e) {
48559       {
48560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48561       };
48562     } catch (std::exception& e) {
48563       {
48564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48565       };
48566     } catch (Dali::DaliException e) {
48567       {
48568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48569       };
48570     } catch (...) {
48571       {
48572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48573       };
48574     }
48575   }
48576
48577   jresult = result;
48578   return jresult;
48579 }
48580
48581
48582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48583   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48584   float arg2 ;
48585
48586   arg1 = (Dali::CameraActor *)jarg1;
48587   arg2 = (float)jarg2;
48588   {
48589     try {
48590       (arg1)->SetAspectRatio(arg2);
48591     } catch (std::out_of_range& e) {
48592       {
48593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48594       };
48595     } catch (std::exception& e) {
48596       {
48597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48598       };
48599     } catch (Dali::DaliException e) {
48600       {
48601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48602       };
48603     } catch (...) {
48604       {
48605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48606       };
48607     }
48608   }
48609
48610 }
48611
48612
48613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48614   float jresult ;
48615   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48616   float result;
48617
48618   arg1 = (Dali::CameraActor *)jarg1;
48619   {
48620     try {
48621       result = (float)(arg1)->GetAspectRatio();
48622     } catch (std::out_of_range& e) {
48623       {
48624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48625       };
48626     } catch (std::exception& e) {
48627       {
48628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48629       };
48630     } catch (Dali::DaliException e) {
48631       {
48632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48633       };
48634     } catch (...) {
48635       {
48636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48637       };
48638     }
48639   }
48640
48641   jresult = result;
48642   return jresult;
48643 }
48644
48645
48646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48647   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48648   float arg2 ;
48649
48650   arg1 = (Dali::CameraActor *)jarg1;
48651   arg2 = (float)jarg2;
48652   {
48653     try {
48654       (arg1)->SetNearClippingPlane(arg2);
48655     } catch (std::out_of_range& e) {
48656       {
48657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48658       };
48659     } catch (std::exception& e) {
48660       {
48661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48662       };
48663     } catch (Dali::DaliException e) {
48664       {
48665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48666       };
48667     } catch (...) {
48668       {
48669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48670       };
48671     }
48672   }
48673
48674 }
48675
48676
48677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48678   float jresult ;
48679   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48680   float result;
48681
48682   arg1 = (Dali::CameraActor *)jarg1;
48683   {
48684     try {
48685       result = (float)(arg1)->GetNearClippingPlane();
48686     } catch (std::out_of_range& e) {
48687       {
48688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48689       };
48690     } catch (std::exception& e) {
48691       {
48692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48693       };
48694     } catch (Dali::DaliException e) {
48695       {
48696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48697       };
48698     } catch (...) {
48699       {
48700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48701       };
48702     }
48703   }
48704
48705   jresult = result;
48706   return jresult;
48707 }
48708
48709
48710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48711   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48712   float arg2 ;
48713
48714   arg1 = (Dali::CameraActor *)jarg1;
48715   arg2 = (float)jarg2;
48716   {
48717     try {
48718       (arg1)->SetFarClippingPlane(arg2);
48719     } catch (std::out_of_range& e) {
48720       {
48721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48722       };
48723     } catch (std::exception& e) {
48724       {
48725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48726       };
48727     } catch (Dali::DaliException e) {
48728       {
48729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48730       };
48731     } catch (...) {
48732       {
48733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48734       };
48735     }
48736   }
48737
48738 }
48739
48740
48741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48742   float jresult ;
48743   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48744   float result;
48745
48746   arg1 = (Dali::CameraActor *)jarg1;
48747   {
48748     try {
48749       result = (float)(arg1)->GetFarClippingPlane();
48750     } catch (std::out_of_range& e) {
48751       {
48752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48753       };
48754     } catch (std::exception& e) {
48755       {
48756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48757       };
48758     } catch (Dali::DaliException e) {
48759       {
48760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48761       };
48762     } catch (...) {
48763       {
48764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48765       };
48766     }
48767   }
48768
48769   jresult = result;
48770   return jresult;
48771 }
48772
48773
48774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48775   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48776   Dali::Vector3 *arg2 = 0 ;
48777
48778   arg1 = (Dali::CameraActor *)jarg1;
48779   arg2 = (Dali::Vector3 *)jarg2;
48780   if (!arg2) {
48781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48782     return ;
48783   }
48784   {
48785     try {
48786       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48787     } catch (std::out_of_range& e) {
48788       {
48789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48790       };
48791     } catch (std::exception& e) {
48792       {
48793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48794       };
48795     } catch (Dali::DaliException e) {
48796       {
48797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48798       };
48799     } catch (...) {
48800       {
48801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48802       };
48803     }
48804   }
48805
48806 }
48807
48808
48809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48810   void * jresult ;
48811   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48812   Dali::Vector3 result;
48813
48814   arg1 = (Dali::CameraActor *)jarg1;
48815   {
48816     try {
48817       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48818     } catch (std::out_of_range& e) {
48819       {
48820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48821       };
48822     } catch (std::exception& e) {
48823       {
48824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48825       };
48826     } catch (Dali::DaliException e) {
48827       {
48828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48829       };
48830     } catch (...) {
48831       {
48832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48833       };
48834     }
48835   }
48836
48837   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48838   return jresult;
48839 }
48840
48841
48842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48843   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48844   bool arg2 ;
48845
48846   arg1 = (Dali::CameraActor *)jarg1;
48847   arg2 = jarg2 ? true : false;
48848   {
48849     try {
48850       (arg1)->SetInvertYAxis(arg2);
48851     } catch (std::out_of_range& e) {
48852       {
48853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48854       };
48855     } catch (std::exception& e) {
48856       {
48857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48858       };
48859     } catch (Dali::DaliException e) {
48860       {
48861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48862       };
48863     } catch (...) {
48864       {
48865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48866       };
48867     }
48868   }
48869
48870 }
48871
48872
48873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48874   unsigned int jresult ;
48875   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48876   bool result;
48877
48878   arg1 = (Dali::CameraActor *)jarg1;
48879   {
48880     try {
48881       result = (bool)(arg1)->GetInvertYAxis();
48882     } catch (std::out_of_range& e) {
48883       {
48884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48885       };
48886     } catch (std::exception& e) {
48887       {
48888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48889       };
48890     } catch (Dali::DaliException e) {
48891       {
48892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48893       };
48894     } catch (...) {
48895       {
48896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48897       };
48898     }
48899   }
48900
48901   jresult = result;
48902   return jresult;
48903 }
48904
48905
48906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48907   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48908   Dali::Size *arg2 = 0 ;
48909
48910   arg1 = (Dali::CameraActor *)jarg1;
48911   arg2 = (Dali::Size *)jarg2;
48912   if (!arg2) {
48913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48914     return ;
48915   }
48916   {
48917     try {
48918       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48919     } catch (std::out_of_range& e) {
48920       {
48921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48922       };
48923     } catch (std::exception& e) {
48924       {
48925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48926       };
48927     } catch (Dali::DaliException e) {
48928       {
48929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48930       };
48931     } catch (...) {
48932       {
48933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48934       };
48935     }
48936   }
48937
48938 }
48939
48940
48941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48942   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48943   Dali::Size *arg2 = 0 ;
48944
48945   arg1 = (Dali::CameraActor *)jarg1;
48946   arg2 = (Dali::Size *)jarg2;
48947   if (!arg2) {
48948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48949     return ;
48950   }
48951   {
48952     try {
48953       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48954     } catch (std::out_of_range& e) {
48955       {
48956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48957       };
48958     } catch (std::exception& e) {
48959       {
48960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48961       };
48962     } catch (Dali::DaliException e) {
48963       {
48964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48965       };
48966     } catch (...) {
48967       {
48968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48969       };
48970     }
48971   }
48972
48973 }
48974
48975
48976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48977   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48978   float arg2 ;
48979   float arg3 ;
48980   float arg4 ;
48981   float arg5 ;
48982   float arg6 ;
48983   float arg7 ;
48984
48985   arg1 = (Dali::CameraActor *)jarg1;
48986   arg2 = (float)jarg2;
48987   arg3 = (float)jarg3;
48988   arg4 = (float)jarg4;
48989   arg5 = (float)jarg5;
48990   arg6 = (float)jarg6;
48991   arg7 = (float)jarg7;
48992   {
48993     try {
48994       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48995     } catch (std::out_of_range& e) {
48996       {
48997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48998       };
48999     } catch (std::exception& e) {
49000       {
49001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49002       };
49003     } catch (Dali::DaliException e) {
49004       {
49005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49006       };
49007     } catch (...) {
49008       {
49009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49010       };
49011     }
49012   }
49013
49014 }
49015
49016
49017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49018   void * jresult ;
49019   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49020
49021   {
49022     try {
49023       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49024     } catch (std::out_of_range& e) {
49025       {
49026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49027       };
49028     } catch (std::exception& e) {
49029       {
49030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49031       };
49032     } catch (Dali::DaliException e) {
49033       {
49034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49035       };
49036     } catch (...) {
49037       {
49038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49039       };
49040     }
49041   }
49042
49043   jresult = (void *)result;
49044   return jresult;
49045 }
49046
49047
49048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49049   void * jresult ;
49050   std::string arg1 ;
49051   Dali::Property::Value arg2 ;
49052   Dali::Property::Value *argp2 ;
49053   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49054
49055   if (!jarg1) {
49056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49057     return 0;
49058   }
49059   (&arg1)->assign(jarg1);
49060   argp2 = (Dali::Property::Value *)jarg2;
49061   if (!argp2) {
49062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49063     return 0;
49064   }
49065   arg2 = *argp2;
49066   {
49067     try {
49068       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49069     } catch (std::out_of_range& e) {
49070       {
49071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49072       };
49073     } catch (std::exception& e) {
49074       {
49075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49076       };
49077     } catch (Dali::DaliException e) {
49078       {
49079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49080       };
49081     } catch (...) {
49082       {
49083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49084       };
49085     }
49086   }
49087
49088   jresult = (void *)result;
49089   return jresult;
49090 }
49091
49092
49093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49094   void * jresult ;
49095   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49096   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49097
49098   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49099   if (!arg1) {
49100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49101     return 0;
49102   }
49103   {
49104     try {
49105       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);
49106     } catch (std::out_of_range& e) {
49107       {
49108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49109       };
49110     } catch (std::exception& e) {
49111       {
49112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49113       };
49114     } catch (Dali::DaliException e) {
49115       {
49116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49117       };
49118     } catch (...) {
49119       {
49120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49121       };
49122     }
49123   }
49124
49125   jresult = (void *)result;
49126   return jresult;
49127 }
49128
49129
49130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49131   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49132   std::string *arg2 = 0 ;
49133
49134   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49135   if (!jarg2) {
49136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49137     return ;
49138   }
49139   std::string arg2_str(jarg2);
49140   arg2 = &arg2_str;
49141   if (arg1) (arg1)->first = *arg2;
49142
49143   //argout typemap for const std::string&
49144
49145 }
49146
49147
49148 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49149   char * jresult ;
49150   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49151   std::string *result = 0 ;
49152
49153   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49154   result = (std::string *) & ((arg1)->first);
49155   jresult = SWIG_csharp_string_callback(result->c_str());
49156   return jresult;
49157 }
49158
49159
49160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49161   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49162   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49163
49164   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49165   arg2 = (Dali::Property::Value *)jarg2;
49166   if (arg1) (arg1)->second = *arg2;
49167 }
49168
49169
49170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49171   void * jresult ;
49172   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49173   Dali::Property::Value *result = 0 ;
49174
49175   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49176   result = (Dali::Property::Value *)& ((arg1)->second);
49177   jresult = (void *)result;
49178   return jresult;
49179 }
49180
49181
49182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49183   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49184
49185   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49186   {
49187     try {
49188       delete arg1;
49189     } catch (std::out_of_range& e) {
49190       {
49191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49192       };
49193     } catch (std::exception& e) {
49194       {
49195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49196       };
49197     } catch (Dali::DaliException e) {
49198       {
49199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49200       };
49201     } catch (...) {
49202       {
49203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49204       };
49205     }
49206   }
49207
49208 }
49209
49210
49211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49212   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49213
49214   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49215   {
49216     try {
49217       (arg1)->clear();
49218     } catch (std::out_of_range& e) {
49219       {
49220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49221       };
49222     } catch (std::exception& e) {
49223       {
49224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49225       };
49226     } catch (Dali::DaliException e) {
49227       {
49228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49229       };
49230     } catch (...) {
49231       {
49232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49233       };
49234     }
49235   }
49236
49237 }
49238
49239
49240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49241   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49242   Dali::TouchPoint *arg2 = 0 ;
49243
49244   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49245   arg2 = (Dali::TouchPoint *)jarg2;
49246   if (!arg2) {
49247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49248     return ;
49249   }
49250   {
49251     try {
49252       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49253     } catch (std::out_of_range& e) {
49254       {
49255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49256       };
49257     } catch (std::exception& e) {
49258       {
49259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49260       };
49261     } catch (Dali::DaliException e) {
49262       {
49263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49264       };
49265     } catch (...) {
49266       {
49267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49268       };
49269     }
49270   }
49271
49272 }
49273
49274
49275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49276   unsigned long jresult ;
49277   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49278   std::vector< Dali::TouchPoint >::size_type result;
49279
49280   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49281   {
49282     try {
49283       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49284     } catch (std::out_of_range& e) {
49285       {
49286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49287       };
49288     } catch (std::exception& e) {
49289       {
49290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49291       };
49292     } catch (Dali::DaliException e) {
49293       {
49294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49295       };
49296     } catch (...) {
49297       {
49298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49299       };
49300     }
49301   }
49302
49303   jresult = (unsigned long)result;
49304   return jresult;
49305 }
49306
49307
49308 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49309   unsigned long jresult ;
49310   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49311   std::vector< Dali::TouchPoint >::size_type result;
49312
49313   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49314   {
49315     try {
49316       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49317     } catch (std::out_of_range& e) {
49318       {
49319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49320       };
49321     } catch (std::exception& e) {
49322       {
49323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49324       };
49325     } catch (Dali::DaliException e) {
49326       {
49327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49328       };
49329     } catch (...) {
49330       {
49331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49332       };
49333     }
49334   }
49335
49336   jresult = (unsigned long)result;
49337   return jresult;
49338 }
49339
49340
49341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49342   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49343   std::vector< Dali::TouchPoint >::size_type arg2 ;
49344
49345   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49346   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49347   {
49348     try {
49349       (arg1)->reserve(arg2);
49350     } catch (std::out_of_range& e) {
49351       {
49352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49353       };
49354     } catch (std::exception& e) {
49355       {
49356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49357       };
49358     } catch (Dali::DaliException e) {
49359       {
49360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49361       };
49362     } catch (...) {
49363       {
49364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49365       };
49366     }
49367   }
49368
49369 }
49370
49371
49372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49373   void * jresult ;
49374   std::vector< Dali::TouchPoint > *result = 0 ;
49375
49376   {
49377     try {
49378       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49379     } catch (std::out_of_range& e) {
49380       {
49381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49382       };
49383     } catch (std::exception& e) {
49384       {
49385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49386       };
49387     } catch (Dali::DaliException e) {
49388       {
49389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49390       };
49391     } catch (...) {
49392       {
49393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49394       };
49395     }
49396   }
49397
49398   jresult = (void *)result;
49399   return jresult;
49400 }
49401
49402
49403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49404   void * jresult ;
49405   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49406   std::vector< Dali::TouchPoint > *result = 0 ;
49407
49408   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49409   if (!arg1) {
49410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49411     return 0;
49412   }
49413   {
49414     try {
49415       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49416     } catch (std::out_of_range& e) {
49417       {
49418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49419       };
49420     } catch (std::exception& e) {
49421       {
49422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49423       };
49424     } catch (Dali::DaliException e) {
49425       {
49426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49427       };
49428     } catch (...) {
49429       {
49430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49431       };
49432     }
49433   }
49434
49435   jresult = (void *)result;
49436   return jresult;
49437 }
49438
49439
49440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49441   void * jresult ;
49442   int arg1 ;
49443   std::vector< Dali::TouchPoint > *result = 0 ;
49444
49445   arg1 = (int)jarg1;
49446   {
49447     try {
49448       try {
49449         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49450       }
49451       catch(std::out_of_range &_e) {
49452         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49453         return 0;
49454       }
49455
49456     } catch (std::out_of_range& e) {
49457       {
49458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49459       };
49460     } catch (std::exception& e) {
49461       {
49462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49463       };
49464     } catch (Dali::DaliException e) {
49465       {
49466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49467       };
49468     } catch (...) {
49469       {
49470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49471       };
49472     }
49473   }
49474
49475   jresult = (void *)result;
49476   return jresult;
49477 }
49478
49479
49480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49481   void * jresult ;
49482   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49483   int arg2 ;
49484   SwigValueWrapper< Dali::TouchPoint > result;
49485
49486   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49487   arg2 = (int)jarg2;
49488   {
49489     try {
49490       try {
49491         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49492       }
49493       catch(std::out_of_range &_e) {
49494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49495         return 0;
49496       }
49497
49498     } catch (std::out_of_range& e) {
49499       {
49500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49501       };
49502     } catch (std::exception& e) {
49503       {
49504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49505       };
49506     } catch (Dali::DaliException e) {
49507       {
49508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49509       };
49510     } catch (...) {
49511       {
49512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49513       };
49514     }
49515   }
49516
49517   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49518   return jresult;
49519 }
49520
49521
49522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49523   void * jresult ;
49524   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49525   int arg2 ;
49526   Dali::TouchPoint *result = 0 ;
49527
49528   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49529   arg2 = (int)jarg2;
49530   {
49531     try {
49532       try {
49533         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49534       }
49535       catch(std::out_of_range &_e) {
49536         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49537         return 0;
49538       }
49539
49540     } catch (std::out_of_range& e) {
49541       {
49542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49543       };
49544     } catch (std::exception& e) {
49545       {
49546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49547       };
49548     } catch (Dali::DaliException e) {
49549       {
49550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49551       };
49552     } catch (...) {
49553       {
49554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49555       };
49556     }
49557   }
49558
49559   jresult = (void *)result;
49560   return jresult;
49561 }
49562
49563
49564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49565   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49566   int arg2 ;
49567   Dali::TouchPoint *arg3 = 0 ;
49568
49569   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49570   arg2 = (int)jarg2;
49571   arg3 = (Dali::TouchPoint *)jarg3;
49572   if (!arg3) {
49573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49574     return ;
49575   }
49576   {
49577     try {
49578       try {
49579         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49580       }
49581       catch(std::out_of_range &_e) {
49582         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49583         return ;
49584       }
49585
49586     } catch (std::out_of_range& e) {
49587       {
49588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49589       };
49590     } catch (std::exception& e) {
49591       {
49592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49593       };
49594     } catch (Dali::DaliException e) {
49595       {
49596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49597       };
49598     } catch (...) {
49599       {
49600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49601       };
49602     }
49603   }
49604
49605 }
49606
49607
49608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49609   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49610   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49611
49612   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49613   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49614   if (!arg2) {
49615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49616     return ;
49617   }
49618   {
49619     try {
49620       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49621     } catch (std::out_of_range& e) {
49622       {
49623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49624       };
49625     } catch (std::exception& e) {
49626       {
49627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49628       };
49629     } catch (Dali::DaliException e) {
49630       {
49631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49632       };
49633     } catch (...) {
49634       {
49635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49636       };
49637     }
49638   }
49639
49640 }
49641
49642
49643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49644   void * jresult ;
49645   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49646   int arg2 ;
49647   int arg3 ;
49648   std::vector< Dali::TouchPoint > *result = 0 ;
49649
49650   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49651   arg2 = (int)jarg2;
49652   arg3 = (int)jarg3;
49653   {
49654     try {
49655       try {
49656         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49657       }
49658       catch(std::out_of_range &_e) {
49659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49660         return 0;
49661       }
49662       catch(std::invalid_argument &_e) {
49663         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49664         return 0;
49665       }
49666
49667     } catch (std::out_of_range& e) {
49668       {
49669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49670       };
49671     } catch (std::exception& e) {
49672       {
49673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49674       };
49675     } catch (Dali::DaliException e) {
49676       {
49677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49678       };
49679     } catch (...) {
49680       {
49681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49682       };
49683     }
49684   }
49685
49686   jresult = (void *)result;
49687   return jresult;
49688 }
49689
49690
49691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49692   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49693   int arg2 ;
49694   Dali::TouchPoint *arg3 = 0 ;
49695
49696   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49697   arg2 = (int)jarg2;
49698   arg3 = (Dali::TouchPoint *)jarg3;
49699   if (!arg3) {
49700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49701     return ;
49702   }
49703   {
49704     try {
49705       try {
49706         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49707       }
49708       catch(std::out_of_range &_e) {
49709         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49710         return ;
49711       }
49712
49713     } catch (std::out_of_range& e) {
49714       {
49715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49716       };
49717     } catch (std::exception& e) {
49718       {
49719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49720       };
49721     } catch (Dali::DaliException e) {
49722       {
49723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49724       };
49725     } catch (...) {
49726       {
49727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49728       };
49729     }
49730   }
49731
49732 }
49733
49734
49735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49736   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49737   int arg2 ;
49738   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49739
49740   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49741   arg2 = (int)jarg2;
49742   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49743   if (!arg3) {
49744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49745     return ;
49746   }
49747   {
49748     try {
49749       try {
49750         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49751       }
49752       catch(std::out_of_range &_e) {
49753         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49754         return ;
49755       }
49756
49757     } catch (std::out_of_range& e) {
49758       {
49759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49760       };
49761     } catch (std::exception& e) {
49762       {
49763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49764       };
49765     } catch (Dali::DaliException e) {
49766       {
49767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49768       };
49769     } catch (...) {
49770       {
49771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49772       };
49773     }
49774   }
49775
49776 }
49777
49778
49779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49780   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49781   int arg2 ;
49782
49783   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49784   arg2 = (int)jarg2;
49785   {
49786     try {
49787       try {
49788         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49789       }
49790       catch(std::out_of_range &_e) {
49791         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49792         return ;
49793       }
49794
49795     } catch (std::out_of_range& e) {
49796       {
49797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49798       };
49799     } catch (std::exception& e) {
49800       {
49801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49802       };
49803     } catch (Dali::DaliException e) {
49804       {
49805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49806       };
49807     } catch (...) {
49808       {
49809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49810       };
49811     }
49812   }
49813
49814 }
49815
49816
49817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49818   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49819   int arg2 ;
49820   int arg3 ;
49821
49822   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49823   arg2 = (int)jarg2;
49824   arg3 = (int)jarg3;
49825   {
49826     try {
49827       try {
49828         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49829       }
49830       catch(std::out_of_range &_e) {
49831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49832         return ;
49833       }
49834       catch(std::invalid_argument &_e) {
49835         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49836         return ;
49837       }
49838
49839     } catch (std::out_of_range& e) {
49840       {
49841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49842       };
49843     } catch (std::exception& e) {
49844       {
49845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49846       };
49847     } catch (Dali::DaliException e) {
49848       {
49849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49850       };
49851     } catch (...) {
49852       {
49853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49854       };
49855     }
49856   }
49857
49858 }
49859
49860
49861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49862   void * jresult ;
49863   Dali::TouchPoint *arg1 = 0 ;
49864   int arg2 ;
49865   std::vector< Dali::TouchPoint > *result = 0 ;
49866
49867   arg1 = (Dali::TouchPoint *)jarg1;
49868   if (!arg1) {
49869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49870     return 0;
49871   }
49872   arg2 = (int)jarg2;
49873   {
49874     try {
49875       try {
49876         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49877       }
49878       catch(std::out_of_range &_e) {
49879         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49880         return 0;
49881       }
49882
49883     } catch (std::out_of_range& e) {
49884       {
49885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49886       };
49887     } catch (std::exception& e) {
49888       {
49889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49890       };
49891     } catch (Dali::DaliException e) {
49892       {
49893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49894       };
49895     } catch (...) {
49896       {
49897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49898       };
49899     }
49900   }
49901
49902   jresult = (void *)result;
49903   return jresult;
49904 }
49905
49906
49907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49908   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49909
49910   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49911   {
49912     try {
49913       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49914     } catch (std::out_of_range& e) {
49915       {
49916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49917       };
49918     } catch (std::exception& e) {
49919       {
49920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49921       };
49922     } catch (Dali::DaliException e) {
49923       {
49924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49925       };
49926     } catch (...) {
49927       {
49928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49929       };
49930     }
49931   }
49932
49933 }
49934
49935
49936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49937   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49938   int arg2 ;
49939   int arg3 ;
49940
49941   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49942   arg2 = (int)jarg2;
49943   arg3 = (int)jarg3;
49944   {
49945     try {
49946       try {
49947         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49948       }
49949       catch(std::out_of_range &_e) {
49950         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49951         return ;
49952       }
49953       catch(std::invalid_argument &_e) {
49954         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49955         return ;
49956       }
49957
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 (Dali::DaliException e) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49969       };
49970     } catch (...) {
49971       {
49972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49973       };
49974     }
49975   }
49976
49977 }
49978
49979
49980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49981   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49982   int arg2 ;
49983   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49984
49985   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49986   arg2 = (int)jarg2;
49987   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49988   if (!arg3) {
49989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49990     return ;
49991   }
49992   {
49993     try {
49994       try {
49995         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49996       }
49997       catch(std::out_of_range &_e) {
49998         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49999         return ;
50000       }
50001
50002     } catch (std::out_of_range& e) {
50003       {
50004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50005       };
50006     } catch (std::exception& e) {
50007       {
50008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50009       };
50010     } catch (Dali::DaliException e) {
50011       {
50012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50013       };
50014     } catch (...) {
50015       {
50016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50017       };
50018     }
50019   }
50020
50021 }
50022
50023
50024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50025   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50026
50027   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50028   {
50029     try {
50030       delete arg1;
50031     } catch (std::out_of_range& e) {
50032       {
50033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50034       };
50035     } catch (std::exception& e) {
50036       {
50037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50038       };
50039     } catch (Dali::DaliException e) {
50040       {
50041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50042       };
50043     } catch (...) {
50044       {
50045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50046       };
50047     }
50048   }
50049
50050 }
50051
50052
50053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50054   void * jresult ;
50055   Dali::Rect< int > *result = 0 ;
50056
50057   {
50058     try {
50059       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50060     } catch (std::out_of_range& e) {
50061       {
50062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50063       };
50064     } catch (std::exception& e) {
50065       {
50066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50067       };
50068     } catch (Dali::DaliException e) {
50069       {
50070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50071       };
50072     } catch (...) {
50073       {
50074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50075       };
50076     }
50077   }
50078
50079   jresult = (void *)result;
50080   return jresult;
50081 }
50082
50083
50084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50085   void * jresult ;
50086   int arg1 ;
50087   int arg2 ;
50088   int arg3 ;
50089   int arg4 ;
50090   Dali::Rect< int > *result = 0 ;
50091
50092   arg1 = (int)jarg1;
50093   arg2 = (int)jarg2;
50094   arg3 = (int)jarg3;
50095   arg4 = (int)jarg4;
50096   {
50097     try {
50098       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50099     } catch (std::out_of_range& e) {
50100       {
50101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50102       };
50103     } catch (std::exception& e) {
50104       {
50105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50106       };
50107     } catch (Dali::DaliException e) {
50108       {
50109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50110       };
50111     } catch (...) {
50112       {
50113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50114       };
50115     }
50116   }
50117
50118   jresult = (void *)result;
50119   return jresult;
50120 }
50121
50122
50123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50124   void * jresult ;
50125   Dali::Rect< int > *arg1 = 0 ;
50126   Dali::Rect< int > *result = 0 ;
50127
50128   arg1 = (Dali::Rect< int > *)jarg1;
50129   if (!arg1) {
50130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50131     return 0;
50132   }
50133   {
50134     try {
50135       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50136     } catch (std::out_of_range& e) {
50137       {
50138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50139       };
50140     } catch (std::exception& e) {
50141       {
50142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50143       };
50144     } catch (Dali::DaliException e) {
50145       {
50146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50147       };
50148     } catch (...) {
50149       {
50150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50151       };
50152     }
50153   }
50154
50155   jresult = (void *)result;
50156   return jresult;
50157 }
50158
50159
50160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50161   void * jresult ;
50162   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50163   Dali::Rect< int > *arg2 = 0 ;
50164   Dali::Rect< int > *result = 0 ;
50165
50166   arg1 = (Dali::Rect< int > *)jarg1;
50167   arg2 = (Dali::Rect< int > *)jarg2;
50168   if (!arg2) {
50169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50170     return 0;
50171   }
50172   {
50173     try {
50174       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50175     } catch (std::out_of_range& e) {
50176       {
50177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50178       };
50179     } catch (std::exception& e) {
50180       {
50181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50182       };
50183     } catch (Dali::DaliException e) {
50184       {
50185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50186       };
50187     } catch (...) {
50188       {
50189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50190       };
50191     }
50192   }
50193
50194   jresult = (void *)result;
50195   return jresult;
50196 }
50197
50198
50199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50200   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50201   int arg2 ;
50202   int arg3 ;
50203   int arg4 ;
50204   int arg5 ;
50205
50206   arg1 = (Dali::Rect< int > *)jarg1;
50207   arg2 = (int)jarg2;
50208   arg3 = (int)jarg3;
50209   arg4 = (int)jarg4;
50210   arg5 = (int)jarg5;
50211   {
50212     try {
50213       (arg1)->Set(arg2,arg3,arg4,arg5);
50214     } catch (std::out_of_range& e) {
50215       {
50216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50217       };
50218     } catch (std::exception& e) {
50219       {
50220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50221       };
50222     } catch (Dali::DaliException e) {
50223       {
50224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50225       };
50226     } catch (...) {
50227       {
50228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50229       };
50230     }
50231   }
50232
50233 }
50234
50235
50236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50237   unsigned int jresult ;
50238   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50239   bool result;
50240
50241   arg1 = (Dali::Rect< int > *)jarg1;
50242   {
50243     try {
50244       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50245     } catch (std::out_of_range& e) {
50246       {
50247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50248       };
50249     } catch (std::exception& e) {
50250       {
50251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50252       };
50253     } catch (Dali::DaliException e) {
50254       {
50255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50256       };
50257     } catch (...) {
50258       {
50259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50260       };
50261     }
50262   }
50263
50264   jresult = result;
50265   return jresult;
50266 }
50267
50268
50269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50270   int jresult ;
50271   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50272   int result;
50273
50274   arg1 = (Dali::Rect< int > *)jarg1;
50275   {
50276     try {
50277       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50278     } catch (std::out_of_range& e) {
50279       {
50280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50281       };
50282     } catch (std::exception& e) {
50283       {
50284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50285       };
50286     } catch (Dali::DaliException e) {
50287       {
50288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50289       };
50290     } catch (...) {
50291       {
50292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50293       };
50294     }
50295   }
50296
50297   jresult = result;
50298   return jresult;
50299 }
50300
50301
50302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50303   int jresult ;
50304   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50305   int result;
50306
50307   arg1 = (Dali::Rect< int > *)jarg1;
50308   {
50309     try {
50310       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50311     } catch (std::out_of_range& e) {
50312       {
50313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50314       };
50315     } catch (std::exception& e) {
50316       {
50317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50318       };
50319     } catch (Dali::DaliException e) {
50320       {
50321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50322       };
50323     } catch (...) {
50324       {
50325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50326       };
50327     }
50328   }
50329
50330   jresult = result;
50331   return jresult;
50332 }
50333
50334
50335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50336   int jresult ;
50337   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50338   int result;
50339
50340   arg1 = (Dali::Rect< int > *)jarg1;
50341   {
50342     try {
50343       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50344     } catch (std::out_of_range& e) {
50345       {
50346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50347       };
50348     } catch (std::exception& e) {
50349       {
50350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50351       };
50352     } catch (Dali::DaliException e) {
50353       {
50354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50355       };
50356     } catch (...) {
50357       {
50358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50359       };
50360     }
50361   }
50362
50363   jresult = result;
50364   return jresult;
50365 }
50366
50367
50368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50369   int jresult ;
50370   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50371   int result;
50372
50373   arg1 = (Dali::Rect< int > *)jarg1;
50374   {
50375     try {
50376       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50377     } catch (std::out_of_range& e) {
50378       {
50379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50380       };
50381     } catch (std::exception& e) {
50382       {
50383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50384       };
50385     } catch (Dali::DaliException e) {
50386       {
50387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50388       };
50389     } catch (...) {
50390       {
50391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50392       };
50393     }
50394   }
50395
50396   jresult = result;
50397   return jresult;
50398 }
50399
50400
50401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50402   int jresult ;
50403   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50404   int result;
50405
50406   arg1 = (Dali::Rect< int > *)jarg1;
50407   {
50408     try {
50409       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50410     } catch (std::out_of_range& e) {
50411       {
50412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50413       };
50414     } catch (std::exception& e) {
50415       {
50416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50417       };
50418     } catch (Dali::DaliException e) {
50419       {
50420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50421       };
50422     } catch (...) {
50423       {
50424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50425       };
50426     }
50427   }
50428
50429   jresult = result;
50430   return jresult;
50431 }
50432
50433
50434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50435   unsigned int jresult ;
50436   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50437   Dali::Rect< int > *arg2 = 0 ;
50438   bool result;
50439
50440   arg1 = (Dali::Rect< int > *)jarg1;
50441   arg2 = (Dali::Rect< int > *)jarg2;
50442   if (!arg2) {
50443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50444     return 0;
50445   }
50446   {
50447     try {
50448       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50449     } catch (std::out_of_range& e) {
50450       {
50451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50452       };
50453     } catch (std::exception& e) {
50454       {
50455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50456       };
50457     } catch (Dali::DaliException e) {
50458       {
50459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50460       };
50461     } catch (...) {
50462       {
50463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50464       };
50465     }
50466   }
50467
50468   jresult = result;
50469   return jresult;
50470 }
50471
50472
50473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50474   unsigned int jresult ;
50475   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50476   Dali::Rect< int > *arg2 = 0 ;
50477   bool result;
50478
50479   arg1 = (Dali::Rect< int > *)jarg1;
50480   arg2 = (Dali::Rect< int > *)jarg2;
50481   if (!arg2) {
50482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50483     return 0;
50484   }
50485   {
50486     try {
50487       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50488     } catch (std::out_of_range& e) {
50489       {
50490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50491       };
50492     } catch (std::exception& e) {
50493       {
50494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50495       };
50496     } catch (Dali::DaliException e) {
50497       {
50498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50499       };
50500     } catch (...) {
50501       {
50502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50503       };
50504     }
50505   }
50506
50507   jresult = result;
50508   return jresult;
50509 }
50510
50511
50512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50513   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50514   int arg2 ;
50515
50516   arg1 = (Dali::Rect< int > *)jarg1;
50517   arg2 = (int)jarg2;
50518   if (arg1) (arg1)->x = arg2;
50519 }
50520
50521
50522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50523   int jresult ;
50524   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50525   int result;
50526
50527   arg1 = (Dali::Rect< int > *)jarg1;
50528   result = (int) ((arg1)->x);
50529   jresult = result;
50530   return jresult;
50531 }
50532
50533
50534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50535   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50536   int arg2 ;
50537
50538   arg1 = (Dali::Rect< int > *)jarg1;
50539   arg2 = (int)jarg2;
50540   if (arg1) (arg1)->left = arg2;
50541 }
50542
50543
50544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50545   int jresult ;
50546   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50547   int result;
50548
50549   arg1 = (Dali::Rect< int > *)jarg1;
50550   result = (int) ((arg1)->left);
50551   jresult = result;
50552   return jresult;
50553 }
50554
50555
50556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50557   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50558   int arg2 ;
50559
50560   arg1 = (Dali::Rect< int > *)jarg1;
50561   arg2 = (int)jarg2;
50562   if (arg1) (arg1)->y = arg2;
50563 }
50564
50565
50566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50567   int jresult ;
50568   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50569   int result;
50570
50571   arg1 = (Dali::Rect< int > *)jarg1;
50572   result = (int) ((arg1)->y);
50573   jresult = result;
50574   return jresult;
50575 }
50576
50577
50578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50579   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50580   int arg2 ;
50581
50582   arg1 = (Dali::Rect< int > *)jarg1;
50583   arg2 = (int)jarg2;
50584   if (arg1) (arg1)->right = arg2;
50585 }
50586
50587
50588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50589   int jresult ;
50590   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50591   int result;
50592
50593   arg1 = (Dali::Rect< int > *)jarg1;
50594   result = (int) ((arg1)->right);
50595   jresult = result;
50596   return jresult;
50597 }
50598
50599
50600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50601   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50602   int arg2 ;
50603
50604   arg1 = (Dali::Rect< int > *)jarg1;
50605   arg2 = (int)jarg2;
50606   if (arg1) (arg1)->width = arg2;
50607 }
50608
50609
50610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50611   int jresult ;
50612   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50613   int result;
50614
50615   arg1 = (Dali::Rect< int > *)jarg1;
50616   result = (int) ((arg1)->width);
50617   jresult = result;
50618   return jresult;
50619 }
50620
50621
50622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50623   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50624   int arg2 ;
50625
50626   arg1 = (Dali::Rect< int > *)jarg1;
50627   arg2 = (int)jarg2;
50628   if (arg1) (arg1)->bottom = arg2;
50629 }
50630
50631
50632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50633   int jresult ;
50634   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50635   int result;
50636
50637   arg1 = (Dali::Rect< int > *)jarg1;
50638   result = (int) ((arg1)->bottom);
50639   jresult = result;
50640   return jresult;
50641 }
50642
50643
50644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50645   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50646   int arg2 ;
50647
50648   arg1 = (Dali::Rect< int > *)jarg1;
50649   arg2 = (int)jarg2;
50650   if (arg1) (arg1)->height = arg2;
50651 }
50652
50653
50654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50655   int jresult ;
50656   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50657   int result;
50658
50659   arg1 = (Dali::Rect< int > *)jarg1;
50660   result = (int) ((arg1)->height);
50661   jresult = result;
50662   return jresult;
50663 }
50664
50665
50666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50667   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50668   int arg2 ;
50669
50670   arg1 = (Dali::Rect< int > *)jarg1;
50671   arg2 = (int)jarg2;
50672   if (arg1) (arg1)->top = arg2;
50673 }
50674
50675
50676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50677   int jresult ;
50678   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50679   int result;
50680
50681   arg1 = (Dali::Rect< int > *)jarg1;
50682   result = (int) ((arg1)->top);
50683   jresult = result;
50684   return jresult;
50685 }
50686
50687
50688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50689   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50690
50691   arg1 = (Dali::Rect< int > *)jarg1;
50692   {
50693     try {
50694       delete arg1;
50695     } catch (std::out_of_range& e) {
50696       {
50697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50698       };
50699     } catch (std::exception& e) {
50700       {
50701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50702       };
50703     } catch (Dali::DaliException e) {
50704       {
50705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50706       };
50707     } catch (...) {
50708       {
50709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50710       };
50711     }
50712   }
50713
50714 }
50715
50716
50717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50718   void * jresult ;
50719   Dali::Rect< float > *result = 0 ;
50720
50721   {
50722     try {
50723       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50724     } catch (std::out_of_range& e) {
50725       {
50726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50727       };
50728     } catch (std::exception& e) {
50729       {
50730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50731       };
50732     } catch (Dali::DaliException e) {
50733       {
50734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50735       };
50736     } catch (...) {
50737       {
50738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50739       };
50740     }
50741   }
50742
50743   jresult = (void *)result;
50744   return jresult;
50745 }
50746
50747
50748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50749   void * jresult ;
50750   float arg1 ;
50751   float arg2 ;
50752   float arg3 ;
50753   float arg4 ;
50754   Dali::Rect< float > *result = 0 ;
50755
50756   arg1 = (float)jarg1;
50757   arg2 = (float)jarg2;
50758   arg3 = (float)jarg4;
50759   arg4 = (float)jarg3;
50760   {
50761     try {
50762       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50763     } catch (std::out_of_range& e) {
50764       {
50765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50766       };
50767     } catch (std::exception& e) {
50768       {
50769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (Dali::DaliException e) {
50772       {
50773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50774       };
50775     } catch (...) {
50776       {
50777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50778       };
50779     }
50780   }
50781
50782   jresult = (void *)result;
50783   return jresult;
50784 }
50785
50786
50787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50788   void * jresult ;
50789   Dali::Rect< float > *arg1 = 0 ;
50790   Dali::Rect< float > *result = 0 ;
50791
50792   arg1 = (Dali::Rect< float > *)jarg1;
50793   if (!arg1) {
50794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50795     return 0;
50796   }
50797   {
50798     try {
50799       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50800     } catch (std::out_of_range& e) {
50801       {
50802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50803       };
50804     } catch (std::exception& e) {
50805       {
50806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50807       };
50808     } catch (Dali::DaliException e) {
50809       {
50810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50811       };
50812     } catch (...) {
50813       {
50814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50815       };
50816     }
50817   }
50818
50819   jresult = (void *)result;
50820   return jresult;
50821 }
50822
50823
50824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50825   void * jresult ;
50826   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50827   Dali::Rect< float > *arg2 = 0 ;
50828   Dali::Rect< float > *result = 0 ;
50829
50830   arg1 = (Dali::Rect< float > *)jarg1;
50831   arg2 = (Dali::Rect< float > *)jarg2;
50832   if (!arg2) {
50833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50834     return 0;
50835   }
50836   {
50837     try {
50838       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50839     } catch (std::out_of_range& e) {
50840       {
50841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50842       };
50843     } catch (std::exception& e) {
50844       {
50845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50846       };
50847     } catch (Dali::DaliException e) {
50848       {
50849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50850       };
50851     } catch (...) {
50852       {
50853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50854       };
50855     }
50856   }
50857
50858   jresult = (void *)result;
50859   return jresult;
50860 }
50861
50862
50863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50864   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50865   float arg2 ;
50866   float arg3 ;
50867   float arg4 ;
50868   float arg5 ;
50869
50870   arg1 = (Dali::Rect< float > *)jarg1;
50871   arg2 = (float)jarg2;
50872   arg3 = (float)jarg3;
50873   arg4 = (float)jarg5;
50874   arg5 = (float)jarg4;
50875   {
50876     try {
50877       (arg1)->Set(arg2,arg3,arg4,arg5);
50878     } catch (std::out_of_range& e) {
50879       {
50880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50881       };
50882     } catch (std::exception& e) {
50883       {
50884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50885       };
50886     } catch (Dali::DaliException e) {
50887       {
50888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50889       };
50890     } catch (...) {
50891       {
50892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50893       };
50894     }
50895   }
50896
50897 }
50898
50899
50900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50901   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50902   float arg2 ;
50903
50904   arg1 = (Dali::Rect< float > *)jarg1;
50905   arg2 = (float)jarg2;
50906   if (arg1) (arg1)->left = arg2;
50907 }
50908
50909
50910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50911   float jresult ;
50912   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50913   float result;
50914
50915   arg1 = (Dali::Rect< float > *)jarg1;
50916   result = (float) ((arg1)->left);
50917   jresult = result;
50918   return jresult;
50919 }
50920
50921
50922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50923   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50924   float arg2 ;
50925
50926   arg1 = (Dali::Rect< float > *)jarg1;
50927   arg2 = (float)jarg2;
50928   if (arg1) (arg1)->left = arg2;
50929 }
50930
50931
50932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50933   float jresult ;
50934   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50935   float result;
50936
50937   arg1 = (Dali::Rect< float > *)jarg1;
50938   result = (float) ((arg1)->left);
50939   jresult = result;
50940   return jresult;
50941 }
50942
50943
50944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50945   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50946   float arg2 ;
50947
50948   arg1 = (Dali::Rect< float > *)jarg1;
50949   arg2 = (float)jarg2;
50950   if (arg1) (arg1)->right = arg2;
50951 }
50952
50953
50954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50955   float jresult ;
50956   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50957   float result;
50958
50959   arg1 = (Dali::Rect< float > *)jarg1;
50960   result = (float) ((arg1)->right);
50961   jresult = result;
50962   return jresult;
50963 }
50964
50965
50966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50967   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50968   float arg2 ;
50969
50970   arg1 = (Dali::Rect< float > *)jarg1;
50971   arg2 = (float)jarg2;
50972   if (arg1) (arg1)->right = arg2;
50973 }
50974
50975
50976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50977   float jresult ;
50978   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50979   float result;
50980
50981   arg1 = (Dali::Rect< float > *)jarg1;
50982   result = (float) ((arg1)->right);
50983   jresult = result;
50984   return jresult;
50985 }
50986
50987
50988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50989   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50990   float arg2 ;
50991
50992   arg1 = (Dali::Rect< float > *)jarg1;
50993   arg2 = (float)jarg2;
50994   if (arg1) (arg1)->bottom = arg2;
50995 }
50996
50997
50998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50999   float jresult ;
51000   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51001   float result;
51002
51003   arg1 = (Dali::Rect< float > *)jarg1;
51004   result = (float) ((arg1)->bottom);
51005   jresult = result;
51006   return jresult;
51007 }
51008
51009
51010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51011   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51012   float arg2 ;
51013
51014   arg1 = (Dali::Rect< float > *)jarg1;
51015   arg2 = (float)jarg2;
51016   if (arg1) (arg1)->top = arg2;
51017 }
51018
51019
51020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51021   float jresult ;
51022   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51023   float result;
51024
51025   arg1 = (Dali::Rect< float > *)jarg1;
51026   result = (float) ((arg1)->top);
51027   jresult = result;
51028   return jresult;
51029 }
51030
51031
51032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51033   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51034
51035   arg1 = (Dali::Rect< float > *)jarg1;
51036   {
51037     try {
51038       delete arg1;
51039     } catch (std::out_of_range& e) {
51040       {
51041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51042       };
51043     } catch (std::exception& e) {
51044       {
51045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51046       };
51047     } catch (Dali::DaliException e) {
51048       {
51049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51050       };
51051     } catch (...) {
51052       {
51053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51054       };
51055     }
51056   }
51057
51058 }
51059
51060
51061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51062   int jresult ;
51063   int result;
51064
51065   result = (int)Dali::Vector< int >::BaseType;
51066   jresult = (int)result;
51067   return jresult;
51068 }
51069
51070
51071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51072   void * jresult ;
51073   Dali::Vector< int > *result = 0 ;
51074
51075   {
51076     try {
51077       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51078     } catch (std::out_of_range& e) {
51079       {
51080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51081       };
51082     } catch (std::exception& e) {
51083       {
51084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51085       };
51086     } catch (Dali::DaliException e) {
51087       {
51088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51089       };
51090     } catch (...) {
51091       {
51092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51093       };
51094     }
51095   }
51096
51097   jresult = (void *)result;
51098   return jresult;
51099 }
51100
51101
51102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51103   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51104
51105   arg1 = (Dali::Vector< int > *)jarg1;
51106   {
51107     try {
51108       delete arg1;
51109     } catch (std::out_of_range& e) {
51110       {
51111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51112       };
51113     } catch (std::exception& e) {
51114       {
51115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51116       };
51117     } catch (Dali::DaliException e) {
51118       {
51119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51120       };
51121     } catch (...) {
51122       {
51123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51124       };
51125     }
51126   }
51127
51128 }
51129
51130
51131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51132   void * jresult ;
51133   Dali::Vector< int > *arg1 = 0 ;
51134   Dali::Vector< int > *result = 0 ;
51135
51136   arg1 = (Dali::Vector< int > *)jarg1;
51137   if (!arg1) {
51138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51139     return 0;
51140   }
51141   {
51142     try {
51143       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51144     } catch (std::out_of_range& e) {
51145       {
51146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51147       };
51148     } catch (std::exception& e) {
51149       {
51150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51151       };
51152     } catch (Dali::DaliException e) {
51153       {
51154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51155       };
51156     } catch (...) {
51157       {
51158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51159       };
51160     }
51161   }
51162
51163   jresult = (void *)result;
51164   return jresult;
51165 }
51166
51167
51168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51169   void * jresult ;
51170   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51171   Dali::Vector< int > *arg2 = 0 ;
51172   Dali::Vector< int > *result = 0 ;
51173
51174   arg1 = (Dali::Vector< int > *)jarg1;
51175   arg2 = (Dali::Vector< int > *)jarg2;
51176   if (!arg2) {
51177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51178     return 0;
51179   }
51180   {
51181     try {
51182       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51183     } catch (std::out_of_range& e) {
51184       {
51185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51186       };
51187     } catch (std::exception& e) {
51188       {
51189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51190       };
51191     } catch (Dali::DaliException e) {
51192       {
51193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51194       };
51195     } catch (...) {
51196       {
51197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51198       };
51199     }
51200   }
51201
51202   jresult = (void *)result;
51203   return jresult;
51204 }
51205
51206
51207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51208   void * jresult ;
51209   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51210   Dali::Vector< int >::Iterator result;
51211
51212   arg1 = (Dali::Vector< int > *)jarg1;
51213   {
51214     try {
51215       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51216     } catch (std::out_of_range& e) {
51217       {
51218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51219       };
51220     } catch (std::exception& e) {
51221       {
51222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51223       };
51224     } catch (Dali::DaliException e) {
51225       {
51226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51227       };
51228     } catch (...) {
51229       {
51230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51231       };
51232     }
51233   }
51234
51235   jresult = (void *)result;
51236   return jresult;
51237 }
51238
51239
51240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51241   void * jresult ;
51242   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51243   Dali::Vector< int >::Iterator result;
51244
51245   arg1 = (Dali::Vector< int > *)jarg1;
51246   {
51247     try {
51248       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51249     } catch (std::out_of_range& e) {
51250       {
51251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51252       };
51253     } catch (std::exception& e) {
51254       {
51255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51256       };
51257     } catch (Dali::DaliException e) {
51258       {
51259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51260       };
51261     } catch (...) {
51262       {
51263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51264       };
51265     }
51266   }
51267
51268   jresult = (void *)result;
51269   return jresult;
51270 }
51271
51272
51273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51274   void * jresult ;
51275   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51276   Dali::Vector< int >::SizeType arg2 ;
51277   Dali::Vector< int >::ItemType *result = 0 ;
51278
51279   arg1 = (Dali::Vector< int > *)jarg1;
51280   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51281   {
51282     try {
51283       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51284     } catch (std::out_of_range& e) {
51285       {
51286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51287       };
51288     } catch (std::exception& e) {
51289       {
51290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51291       };
51292     } catch (Dali::DaliException e) {
51293       {
51294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51295       };
51296     } catch (...) {
51297       {
51298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51299       };
51300     }
51301   }
51302
51303   jresult = (void *)result;
51304   return jresult;
51305 }
51306
51307
51308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51309   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51310   Dali::Vector< int >::ItemType *arg2 = 0 ;
51311   Dali::Vector< int >::ItemType temp2 ;
51312
51313   arg1 = (Dali::Vector< int > *)jarg1;
51314   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51315   arg2 = &temp2;
51316   {
51317     try {
51318       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51319     } catch (std::out_of_range& e) {
51320       {
51321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51322       };
51323     } catch (std::exception& e) {
51324       {
51325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51326       };
51327     } catch (Dali::DaliException e) {
51328       {
51329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51330       };
51331     } catch (...) {
51332       {
51333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51334       };
51335     }
51336   }
51337
51338 }
51339
51340
51341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51342   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51343   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51344   Dali::Vector< int >::ItemType *arg3 = 0 ;
51345   Dali::Vector< int >::ItemType temp3 ;
51346
51347   arg1 = (Dali::Vector< int > *)jarg1;
51348   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51349   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51350   arg3 = &temp3;
51351   {
51352     try {
51353       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51354     } catch (std::out_of_range& e) {
51355       {
51356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51357       };
51358     } catch (std::exception& e) {
51359       {
51360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51361       };
51362     } catch (Dali::DaliException e) {
51363       {
51364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51365       };
51366     } catch (...) {
51367       {
51368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51369       };
51370     }
51371   }
51372
51373 }
51374
51375
51376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51377   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51378   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51379   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51380   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51381
51382   arg1 = (Dali::Vector< int > *)jarg1;
51383   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51384   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51385   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51386   {
51387     try {
51388       (arg1)->Insert(arg2,arg3,arg4);
51389     } catch (std::out_of_range& e) {
51390       {
51391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51392       };
51393     } catch (std::exception& e) {
51394       {
51395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51396       };
51397     } catch (Dali::DaliException e) {
51398       {
51399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51400       };
51401     } catch (...) {
51402       {
51403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51404       };
51405     }
51406   }
51407
51408 }
51409
51410
51411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51412   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51413   Dali::Vector< int >::SizeType arg2 ;
51414
51415   arg1 = (Dali::Vector< int > *)jarg1;
51416   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51417   {
51418     try {
51419       (arg1)->Reserve(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 (Dali::DaliException e) {
51429       {
51430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51431       };
51432     } catch (...) {
51433       {
51434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51435       };
51436     }
51437   }
51438
51439 }
51440
51441
51442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51443   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51444   Dali::Vector< int >::SizeType arg2 ;
51445
51446   arg1 = (Dali::Vector< int > *)jarg1;
51447   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51448   {
51449     try {
51450       (arg1)->Resize(arg2);
51451     } catch (std::out_of_range& e) {
51452       {
51453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51454       };
51455     } catch (std::exception& e) {
51456       {
51457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51458       };
51459     } catch (Dali::DaliException e) {
51460       {
51461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51462       };
51463     } catch (...) {
51464       {
51465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51466       };
51467     }
51468   }
51469
51470 }
51471
51472
51473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51474   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51475   Dali::Vector< int >::SizeType arg2 ;
51476   Dali::Vector< int >::ItemType *arg3 = 0 ;
51477   Dali::Vector< int >::ItemType temp3 ;
51478
51479   arg1 = (Dali::Vector< int > *)jarg1;
51480   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51481   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51482   arg3 = &temp3;
51483   {
51484     try {
51485       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51486     } catch (std::out_of_range& e) {
51487       {
51488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51489       };
51490     } catch (std::exception& e) {
51491       {
51492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51493       };
51494     } catch (Dali::DaliException e) {
51495       {
51496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51497       };
51498     } catch (...) {
51499       {
51500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51501       };
51502     }
51503   }
51504
51505 }
51506
51507
51508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51509   void * jresult ;
51510   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51511   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51512   Dali::Vector< int >::Iterator result;
51513
51514   arg1 = (Dali::Vector< int > *)jarg1;
51515   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51516   {
51517     try {
51518       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51519     } catch (std::out_of_range& e) {
51520       {
51521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51522       };
51523     } catch (std::exception& e) {
51524       {
51525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51526       };
51527     } catch (Dali::DaliException e) {
51528       {
51529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51530       };
51531     } catch (...) {
51532       {
51533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51534       };
51535     }
51536   }
51537
51538   jresult = (void *)result;
51539   return jresult;
51540 }
51541
51542
51543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51544   void * jresult ;
51545   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51546   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51547   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51548   Dali::Vector< int >::Iterator result;
51549
51550   arg1 = (Dali::Vector< int > *)jarg1;
51551   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51552   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51553   {
51554     try {
51555       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51556     } catch (std::out_of_range& e) {
51557       {
51558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51559       };
51560     } catch (std::exception& e) {
51561       {
51562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51563       };
51564     } catch (Dali::DaliException e) {
51565       {
51566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51567       };
51568     } catch (...) {
51569       {
51570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51571       };
51572     }
51573   }
51574
51575   jresult = (void *)result;
51576   return jresult;
51577 }
51578
51579
51580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51581   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51582   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51583
51584   arg1 = (Dali::Vector< int > *)jarg1;
51585   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51586   {
51587     try {
51588       (arg1)->Remove(arg2);
51589     } catch (std::out_of_range& e) {
51590       {
51591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51592       };
51593     } catch (std::exception& e) {
51594       {
51595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51596       };
51597     } catch (Dali::DaliException e) {
51598       {
51599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51600       };
51601     } catch (...) {
51602       {
51603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51604       };
51605     }
51606   }
51607
51608 }
51609
51610
51611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51612   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51613   Dali::Vector< int > *arg2 = 0 ;
51614
51615   arg1 = (Dali::Vector< int > *)jarg1;
51616   arg2 = (Dali::Vector< int > *)jarg2;
51617   if (!arg2) {
51618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51619     return ;
51620   }
51621   {
51622     try {
51623       (arg1)->Swap(*arg2);
51624     } catch (std::out_of_range& e) {
51625       {
51626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51627       };
51628     } catch (std::exception& e) {
51629       {
51630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51631       };
51632     } catch (Dali::DaliException e) {
51633       {
51634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51635       };
51636     } catch (...) {
51637       {
51638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51639       };
51640     }
51641   }
51642
51643 }
51644
51645
51646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51647   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51648
51649   arg1 = (Dali::Vector< int > *)jarg1;
51650   {
51651     try {
51652       (arg1)->Clear();
51653     } catch (std::out_of_range& e) {
51654       {
51655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51656       };
51657     } catch (std::exception& e) {
51658       {
51659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51660       };
51661     } catch (Dali::DaliException e) {
51662       {
51663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51664       };
51665     } catch (...) {
51666       {
51667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51668       };
51669     }
51670   }
51671
51672 }
51673
51674
51675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51676   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51677
51678   arg1 = (Dali::Vector< int > *)jarg1;
51679   {
51680     try {
51681       (arg1)->Release();
51682     } catch (std::out_of_range& e) {
51683       {
51684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51685       };
51686     } catch (std::exception& e) {
51687       {
51688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51689       };
51690     } catch (Dali::DaliException e) {
51691       {
51692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51693       };
51694     } catch (...) {
51695       {
51696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51697       };
51698     }
51699   }
51700
51701 }
51702
51703
51704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51705   int jresult ;
51706   int result;
51707
51708   result = (int)Dali::Vector< float >::BaseType;
51709   jresult = (int)result;
51710   return jresult;
51711 }
51712
51713
51714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51715   void * jresult ;
51716   Dali::Vector< float > *result = 0 ;
51717
51718   {
51719     try {
51720       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51721     } catch (std::out_of_range& e) {
51722       {
51723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51724       };
51725     } catch (std::exception& e) {
51726       {
51727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51728       };
51729     } catch (Dali::DaliException e) {
51730       {
51731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51732       };
51733     } catch (...) {
51734       {
51735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51736       };
51737     }
51738   }
51739
51740   jresult = (void *)result;
51741   return jresult;
51742 }
51743
51744
51745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51746   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51747
51748   arg1 = (Dali::Vector< float > *)jarg1;
51749   {
51750     try {
51751       delete arg1;
51752     } catch (std::out_of_range& e) {
51753       {
51754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51755       };
51756     } catch (std::exception& e) {
51757       {
51758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51759       };
51760     } catch (Dali::DaliException e) {
51761       {
51762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51763       };
51764     } catch (...) {
51765       {
51766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51767       };
51768     }
51769   }
51770
51771 }
51772
51773
51774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51775   void * jresult ;
51776   Dali::Vector< float > *arg1 = 0 ;
51777   Dali::Vector< float > *result = 0 ;
51778
51779   arg1 = (Dali::Vector< float > *)jarg1;
51780   if (!arg1) {
51781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51782     return 0;
51783   }
51784   {
51785     try {
51786       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51787     } catch (std::out_of_range& e) {
51788       {
51789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51790       };
51791     } catch (std::exception& e) {
51792       {
51793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51794       };
51795     } catch (Dali::DaliException e) {
51796       {
51797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51798       };
51799     } catch (...) {
51800       {
51801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51802       };
51803     }
51804   }
51805
51806   jresult = (void *)result;
51807   return jresult;
51808 }
51809
51810
51811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51812   void * jresult ;
51813   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51814   Dali::Vector< float > *arg2 = 0 ;
51815   Dali::Vector< float > *result = 0 ;
51816
51817   arg1 = (Dali::Vector< float > *)jarg1;
51818   arg2 = (Dali::Vector< float > *)jarg2;
51819   if (!arg2) {
51820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51821     return 0;
51822   }
51823   {
51824     try {
51825       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51826     } catch (std::out_of_range& e) {
51827       {
51828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51829       };
51830     } catch (std::exception& e) {
51831       {
51832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51833       };
51834     } catch (Dali::DaliException e) {
51835       {
51836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51837       };
51838     } catch (...) {
51839       {
51840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51841       };
51842     }
51843   }
51844
51845   jresult = (void *)result;
51846   return jresult;
51847 }
51848
51849
51850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51851   void * jresult ;
51852   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51853   Dali::Vector< float >::Iterator result;
51854
51855   arg1 = (Dali::Vector< float > *)jarg1;
51856   {
51857     try {
51858       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51859     } catch (std::out_of_range& e) {
51860       {
51861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51862       };
51863     } catch (std::exception& e) {
51864       {
51865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51866       };
51867     } catch (Dali::DaliException e) {
51868       {
51869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51870       };
51871     } catch (...) {
51872       {
51873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51874       };
51875     }
51876   }
51877
51878   jresult = (void *)result;
51879   return jresult;
51880 }
51881
51882
51883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51884   void * jresult ;
51885   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51886   Dali::Vector< float >::Iterator result;
51887
51888   arg1 = (Dali::Vector< float > *)jarg1;
51889   {
51890     try {
51891       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51892     } catch (std::out_of_range& e) {
51893       {
51894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51895       };
51896     } catch (std::exception& e) {
51897       {
51898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51899       };
51900     } catch (Dali::DaliException e) {
51901       {
51902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51903       };
51904     } catch (...) {
51905       {
51906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51907       };
51908     }
51909   }
51910
51911   jresult = (void *)result;
51912   return jresult;
51913 }
51914
51915
51916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51917   void * jresult ;
51918   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51919   Dali::Vector< float >::SizeType arg2 ;
51920   Dali::Vector< float >::ItemType *result = 0 ;
51921
51922   arg1 = (Dali::Vector< float > *)jarg1;
51923   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51924   {
51925     try {
51926       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51927     } catch (std::out_of_range& e) {
51928       {
51929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51930       };
51931     } catch (std::exception& e) {
51932       {
51933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51934       };
51935     } catch (Dali::DaliException e) {
51936       {
51937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51938       };
51939     } catch (...) {
51940       {
51941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51942       };
51943     }
51944   }
51945
51946   jresult = (void *)result;
51947   return jresult;
51948 }
51949
51950
51951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51952   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51953   Dali::Vector< float >::ItemType *arg2 = 0 ;
51954   Dali::Vector< float >::ItemType temp2 ;
51955
51956   arg1 = (Dali::Vector< float > *)jarg1;
51957   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51958   arg2 = &temp2;
51959   {
51960     try {
51961       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51962     } catch (std::out_of_range& e) {
51963       {
51964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51965       };
51966     } catch (std::exception& e) {
51967       {
51968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51969       };
51970     } catch (Dali::DaliException e) {
51971       {
51972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51973       };
51974     } catch (...) {
51975       {
51976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51977       };
51978     }
51979   }
51980
51981 }
51982
51983
51984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51985   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51986   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51987   Dali::Vector< float >::ItemType *arg3 = 0 ;
51988   Dali::Vector< float >::ItemType temp3 ;
51989
51990   arg1 = (Dali::Vector< float > *)jarg1;
51991   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51992   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51993   arg3 = &temp3;
51994   {
51995     try {
51996       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51997     } catch (std::out_of_range& e) {
51998       {
51999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52000       };
52001     } catch (std::exception& e) {
52002       {
52003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52004       };
52005     } catch (Dali::DaliException e) {
52006       {
52007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52008       };
52009     } catch (...) {
52010       {
52011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52012       };
52013     }
52014   }
52015
52016 }
52017
52018
52019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52020   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52021   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52022   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52023   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52024
52025   arg1 = (Dali::Vector< float > *)jarg1;
52026   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52027   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52028   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52029   {
52030     try {
52031       (arg1)->Insert(arg2,arg3,arg4);
52032     } catch (std::out_of_range& e) {
52033       {
52034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52035       };
52036     } catch (std::exception& e) {
52037       {
52038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52039       };
52040     } catch (Dali::DaliException e) {
52041       {
52042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52043       };
52044     } catch (...) {
52045       {
52046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52047       };
52048     }
52049   }
52050
52051 }
52052
52053
52054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52055   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52056   Dali::Vector< float >::SizeType arg2 ;
52057
52058   arg1 = (Dali::Vector< float > *)jarg1;
52059   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52060   {
52061     try {
52062       (arg1)->Reserve(arg2);
52063     } catch (std::out_of_range& e) {
52064       {
52065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52066       };
52067     } catch (std::exception& e) {
52068       {
52069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52070       };
52071     } catch (Dali::DaliException e) {
52072       {
52073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52074       };
52075     } catch (...) {
52076       {
52077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52078       };
52079     }
52080   }
52081
52082 }
52083
52084 //// ========================= end of part 2 =============================
52085
52086 //// ========================== start part 3 ===============================
52087
52088
52089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52090   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52091   Dali::Vector< float >::SizeType arg2 ;
52092
52093   arg1 = (Dali::Vector< float > *)jarg1;
52094   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52095   {
52096     try {
52097       (arg1)->Resize(arg2);
52098     } catch (std::out_of_range& e) {
52099       {
52100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52101       };
52102     } catch (std::exception& e) {
52103       {
52104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52105       };
52106     } catch (Dali::DaliException e) {
52107       {
52108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52109       };
52110     } catch (...) {
52111       {
52112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52113       };
52114     }
52115   }
52116
52117 }
52118
52119
52120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52121   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52122   Dali::Vector< float >::SizeType arg2 ;
52123   Dali::Vector< float >::ItemType *arg3 = 0 ;
52124   Dali::Vector< float >::ItemType temp3 ;
52125
52126   arg1 = (Dali::Vector< float > *)jarg1;
52127   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52128   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52129   arg3 = &temp3;
52130   {
52131     try {
52132       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52133     } catch (std::out_of_range& e) {
52134       {
52135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52136       };
52137     } catch (std::exception& e) {
52138       {
52139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52140       };
52141     } catch (Dali::DaliException e) {
52142       {
52143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52144       };
52145     } catch (...) {
52146       {
52147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52148       };
52149     }
52150   }
52151
52152 }
52153
52154
52155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52156   void * jresult ;
52157   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52158   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52159   Dali::Vector< float >::Iterator result;
52160
52161   arg1 = (Dali::Vector< float > *)jarg1;
52162   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52163   {
52164     try {
52165       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52166     } catch (std::out_of_range& e) {
52167       {
52168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52169       };
52170     } catch (std::exception& e) {
52171       {
52172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52173       };
52174     } catch (Dali::DaliException e) {
52175       {
52176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52177       };
52178     } catch (...) {
52179       {
52180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52181       };
52182     }
52183   }
52184
52185   jresult = (void *)result;
52186   return jresult;
52187 }
52188
52189
52190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52191   void * jresult ;
52192   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52193   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52194   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52195   Dali::Vector< float >::Iterator result;
52196
52197   arg1 = (Dali::Vector< float > *)jarg1;
52198   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52199   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52200   {
52201     try {
52202       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52203     } catch (std::out_of_range& e) {
52204       {
52205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52206       };
52207     } catch (std::exception& e) {
52208       {
52209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52210       };
52211     } catch (Dali::DaliException e) {
52212       {
52213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52214       };
52215     } catch (...) {
52216       {
52217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52218       };
52219     }
52220   }
52221
52222   jresult = (void *)result;
52223   return jresult;
52224 }
52225
52226
52227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52228   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52229   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52230
52231   arg1 = (Dali::Vector< float > *)jarg1;
52232   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52233   {
52234     try {
52235       (arg1)->Remove(arg2);
52236     } catch (std::out_of_range& e) {
52237       {
52238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52239       };
52240     } catch (std::exception& e) {
52241       {
52242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52243       };
52244     } catch (Dali::DaliException e) {
52245       {
52246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52247       };
52248     } catch (...) {
52249       {
52250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52251       };
52252     }
52253   }
52254
52255 }
52256
52257
52258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52259   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52260   Dali::Vector< float > *arg2 = 0 ;
52261
52262   arg1 = (Dali::Vector< float > *)jarg1;
52263   arg2 = (Dali::Vector< float > *)jarg2;
52264   if (!arg2) {
52265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52266     return ;
52267   }
52268   {
52269     try {
52270       (arg1)->Swap(*arg2);
52271     } catch (std::out_of_range& e) {
52272       {
52273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52274       };
52275     } catch (std::exception& e) {
52276       {
52277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52278       };
52279     } catch (Dali::DaliException e) {
52280       {
52281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52282       };
52283     } catch (...) {
52284       {
52285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52286       };
52287     }
52288   }
52289
52290 }
52291
52292
52293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52294   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52295
52296   arg1 = (Dali::Vector< float > *)jarg1;
52297   {
52298     try {
52299       (arg1)->Clear();
52300     } catch (std::out_of_range& e) {
52301       {
52302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52303       };
52304     } catch (std::exception& e) {
52305       {
52306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52307       };
52308     } catch (Dali::DaliException e) {
52309       {
52310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52311       };
52312     } catch (...) {
52313       {
52314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52315       };
52316     }
52317   }
52318
52319 }
52320
52321
52322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52323   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52324
52325   arg1 = (Dali::Vector< float > *)jarg1;
52326   {
52327     try {
52328       (arg1)->Release();
52329     } catch (std::out_of_range& e) {
52330       {
52331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52332       };
52333     } catch (std::exception& e) {
52334       {
52335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52336       };
52337     } catch (Dali::DaliException e) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52340       };
52341     } catch (...) {
52342       {
52343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52344       };
52345     }
52346   }
52347
52348 }
52349
52350
52351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52352   int jresult ;
52353   int result;
52354
52355   result = (int)Dali::Vector< unsigned char >::BaseType;
52356   jresult = (int)result;
52357   return jresult;
52358 }
52359
52360
52361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52362   void * jresult ;
52363   Dali::Vector< unsigned char > *result = 0 ;
52364
52365   {
52366     try {
52367       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52368     } catch (std::out_of_range& e) {
52369       {
52370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52371       };
52372     } catch (std::exception& e) {
52373       {
52374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52375       };
52376     } catch (Dali::DaliException e) {
52377       {
52378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52379       };
52380     } catch (...) {
52381       {
52382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52383       };
52384     }
52385   }
52386
52387   jresult = (void *)result;
52388   return jresult;
52389 }
52390
52391
52392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52393   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52394
52395   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52396   {
52397     try {
52398       delete arg1;
52399     } catch (std::out_of_range& e) {
52400       {
52401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52402       };
52403     } catch (std::exception& e) {
52404       {
52405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52406       };
52407     } catch (Dali::DaliException e) {
52408       {
52409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52410       };
52411     } catch (...) {
52412       {
52413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52414       };
52415     }
52416   }
52417
52418 }
52419
52420
52421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52422   void * jresult ;
52423   Dali::Vector< unsigned char > *arg1 = 0 ;
52424   Dali::Vector< unsigned char > *result = 0 ;
52425
52426   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52427   if (!arg1) {
52428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52429     return 0;
52430   }
52431   {
52432     try {
52433       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52434     } catch (std::out_of_range& e) {
52435       {
52436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52437       };
52438     } catch (std::exception& e) {
52439       {
52440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52441       };
52442     } catch (Dali::DaliException e) {
52443       {
52444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52445       };
52446     } catch (...) {
52447       {
52448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52449       };
52450     }
52451   }
52452
52453   jresult = (void *)result;
52454   return jresult;
52455 }
52456
52457
52458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52459   void * jresult ;
52460   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52461   Dali::Vector< unsigned char > *arg2 = 0 ;
52462   Dali::Vector< unsigned char > *result = 0 ;
52463
52464   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52465   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52466   if (!arg2) {
52467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52468     return 0;
52469   }
52470   {
52471     try {
52472       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52473     } catch (std::out_of_range& e) {
52474       {
52475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52476       };
52477     } catch (std::exception& e) {
52478       {
52479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52480       };
52481     } catch (Dali::DaliException e) {
52482       {
52483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52484       };
52485     } catch (...) {
52486       {
52487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52488       };
52489     }
52490   }
52491
52492   jresult = (void *)result;
52493   return jresult;
52494 }
52495
52496
52497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52498   void * jresult ;
52499   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52500   Dali::Vector< unsigned char >::Iterator result;
52501
52502   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52503   {
52504     try {
52505       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52506     } catch (std::out_of_range& e) {
52507       {
52508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52509       };
52510     } catch (std::exception& e) {
52511       {
52512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52513       };
52514     } catch (Dali::DaliException e) {
52515       {
52516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52517       };
52518     } catch (...) {
52519       {
52520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52521       };
52522     }
52523   }
52524
52525   jresult = (void *)result;
52526   return jresult;
52527 }
52528
52529
52530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52531   void * jresult ;
52532   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52533   Dali::Vector< unsigned char >::Iterator result;
52534
52535   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52536   {
52537     try {
52538       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52539     } catch (std::out_of_range& e) {
52540       {
52541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52542       };
52543     } catch (std::exception& e) {
52544       {
52545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52546       };
52547     } catch (Dali::DaliException e) {
52548       {
52549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52550       };
52551     } catch (...) {
52552       {
52553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52554       };
52555     }
52556   }
52557
52558   jresult = (void *)result;
52559   return jresult;
52560 }
52561
52562
52563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52564   void * jresult ;
52565   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52566   Dali::Vector< unsigned char >::SizeType arg2 ;
52567   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52568
52569   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52570   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52571   {
52572     try {
52573       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52574     } catch (std::out_of_range& e) {
52575       {
52576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52577       };
52578     } catch (std::exception& e) {
52579       {
52580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52581       };
52582     } catch (Dali::DaliException e) {
52583       {
52584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52585       };
52586     } catch (...) {
52587       {
52588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52589       };
52590     }
52591   }
52592
52593   jresult = (void *)result;
52594   return jresult;
52595 }
52596
52597
52598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52599   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52600   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52601   Dali::Vector< unsigned char >::ItemType temp2 ;
52602
52603   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52604   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52605   arg2 = &temp2;
52606   {
52607     try {
52608       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52609     } catch (std::out_of_range& e) {
52610       {
52611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52612       };
52613     } catch (std::exception& e) {
52614       {
52615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52616       };
52617     } catch (Dali::DaliException e) {
52618       {
52619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52620       };
52621     } catch (...) {
52622       {
52623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52624       };
52625     }
52626   }
52627
52628 }
52629
52630
52631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52632   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52633   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52634   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52635   Dali::Vector< unsigned char >::ItemType temp3 ;
52636
52637   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52638   arg2 = jarg2;
52639   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52640   arg3 = &temp3;
52641   {
52642     try {
52643       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52644     } catch (std::out_of_range& e) {
52645       {
52646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52647       };
52648     } catch (std::exception& e) {
52649       {
52650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52651       };
52652     } catch (Dali::DaliException e) {
52653       {
52654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52655       };
52656     } catch (...) {
52657       {
52658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52659       };
52660     }
52661   }
52662
52663
52664
52665 }
52666
52667
52668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52669   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52670   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52671   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52672   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52673
52674   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52675   arg2 = jarg2;
52676   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52677   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52678   {
52679     try {
52680       (arg1)->Insert(arg2,arg3,arg4);
52681     } catch (std::out_of_range& e) {
52682       {
52683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52684       };
52685     } catch (std::exception& e) {
52686       {
52687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52688       };
52689     } catch (Dali::DaliException e) {
52690       {
52691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52692       };
52693     } catch (...) {
52694       {
52695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52696       };
52697     }
52698   }
52699
52700
52701
52702 }
52703
52704
52705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52706   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52707   Dali::Vector< unsigned char >::SizeType arg2 ;
52708
52709   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52710   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52711   {
52712     try {
52713       (arg1)->Reserve(arg2);
52714     } catch (std::out_of_range& e) {
52715       {
52716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52717       };
52718     } catch (std::exception& e) {
52719       {
52720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52721       };
52722     } catch (Dali::DaliException e) {
52723       {
52724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52725       };
52726     } catch (...) {
52727       {
52728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52729       };
52730     }
52731   }
52732
52733 }
52734
52735
52736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52737   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52738   Dali::Vector< unsigned char >::SizeType arg2 ;
52739
52740   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52741   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52742   {
52743     try {
52744       (arg1)->Resize(arg2);
52745     } catch (std::out_of_range& e) {
52746       {
52747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52748       };
52749     } catch (std::exception& e) {
52750       {
52751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52752       };
52753     } catch (Dali::DaliException e) {
52754       {
52755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52756       };
52757     } catch (...) {
52758       {
52759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52760       };
52761     }
52762   }
52763
52764 }
52765
52766
52767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52768   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52769   Dali::Vector< unsigned char >::SizeType arg2 ;
52770   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52771   Dali::Vector< unsigned char >::ItemType temp3 ;
52772
52773   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52774   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52775   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52776   arg3 = &temp3;
52777   {
52778     try {
52779       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52780     } catch (std::out_of_range& e) {
52781       {
52782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52783       };
52784     } catch (std::exception& e) {
52785       {
52786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52787       };
52788     } catch (Dali::DaliException e) {
52789       {
52790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52791       };
52792     } catch (...) {
52793       {
52794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52795       };
52796     }
52797   }
52798
52799 }
52800
52801
52802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52803   void * jresult ;
52804   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52805   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52806   Dali::Vector< unsigned char >::Iterator result;
52807
52808   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52809   arg2 = jarg2;
52810   {
52811     try {
52812       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52813     } catch (std::out_of_range& e) {
52814       {
52815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52816       };
52817     } catch (std::exception& e) {
52818       {
52819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52820       };
52821     } catch (Dali::DaliException e) {
52822       {
52823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52824       };
52825     } catch (...) {
52826       {
52827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52828       };
52829     }
52830   }
52831
52832   jresult = (void *)result;
52833
52834
52835   return jresult;
52836 }
52837
52838
52839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52840   void * jresult ;
52841   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52842   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52843   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52844   Dali::Vector< unsigned char >::Iterator result;
52845
52846   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52847   arg2 = jarg2;
52848   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52849   {
52850     try {
52851       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52852     } catch (std::out_of_range& e) {
52853       {
52854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52855       };
52856     } catch (std::exception& e) {
52857       {
52858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52859       };
52860     } catch (Dali::DaliException e) {
52861       {
52862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52863       };
52864     } catch (...) {
52865       {
52866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52867       };
52868     }
52869   }
52870
52871   jresult = (void *)result;
52872
52873
52874   return jresult;
52875 }
52876
52877
52878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52879   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52880   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52881
52882   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52883   arg2 = jarg2;
52884   {
52885     try {
52886       (arg1)->Remove(arg2);
52887     } catch (std::out_of_range& e) {
52888       {
52889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52890       };
52891     } catch (std::exception& e) {
52892       {
52893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52894       };
52895     } catch (Dali::DaliException e) {
52896       {
52897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52898       };
52899     } catch (...) {
52900       {
52901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52902       };
52903     }
52904   }
52905
52906
52907
52908 }
52909
52910
52911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52912   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52913   Dali::Vector< unsigned char > *arg2 = 0 ;
52914
52915   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52916   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52917   if (!arg2) {
52918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52919     return ;
52920   }
52921   {
52922     try {
52923       (arg1)->Swap(*arg2);
52924     } catch (std::out_of_range& e) {
52925       {
52926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52927       };
52928     } catch (std::exception& e) {
52929       {
52930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52931       };
52932     } catch (Dali::DaliException e) {
52933       {
52934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52935       };
52936     } catch (...) {
52937       {
52938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52939       };
52940     }
52941   }
52942
52943 }
52944
52945
52946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52947   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52948
52949   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52950   {
52951     try {
52952       (arg1)->Clear();
52953     } catch (std::out_of_range& e) {
52954       {
52955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52956       };
52957     } catch (std::exception& e) {
52958       {
52959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52960       };
52961     } catch (Dali::DaliException e) {
52962       {
52963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52964       };
52965     } catch (...) {
52966       {
52967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52968       };
52969     }
52970   }
52971
52972 }
52973
52974
52975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52976   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52977
52978   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52979   {
52980     try {
52981       (arg1)->Release();
52982     } catch (std::out_of_range& e) {
52983       {
52984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52985       };
52986     } catch (std::exception& e) {
52987       {
52988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52989       };
52990     } catch (Dali::DaliException e) {
52991       {
52992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52993       };
52994     } catch (...) {
52995       {
52996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52997       };
52998     }
52999   }
53000
53001 }
53002
53003
53004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53005   int jresult ;
53006   int result;
53007
53008   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53009   jresult = (int)result;
53010   return jresult;
53011 }
53012
53013
53014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53015   void * jresult ;
53016   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53017
53018   {
53019     try {
53020       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53021     } catch (std::out_of_range& e) {
53022       {
53023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53024       };
53025     } catch (std::exception& e) {
53026       {
53027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53028       };
53029     } catch (Dali::DaliException e) {
53030       {
53031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53032       };
53033     } catch (...) {
53034       {
53035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53036       };
53037     }
53038   }
53039
53040   jresult = (void *)result;
53041   return jresult;
53042 }
53043
53044
53045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53046   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53047
53048   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53049   {
53050     try {
53051       delete arg1;
53052     } catch (std::out_of_range& e) {
53053       {
53054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53055       };
53056     } catch (std::exception& e) {
53057       {
53058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53059       };
53060     } catch (Dali::DaliException e) {
53061       {
53062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53063       };
53064     } catch (...) {
53065       {
53066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53067       };
53068     }
53069   }
53070
53071 }
53072
53073
53074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53075   void * jresult ;
53076   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53077   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53078
53079   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53080   if (!arg1) {
53081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53082     return 0;
53083   }
53084   {
53085     try {
53086       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53087     } catch (std::out_of_range& e) {
53088       {
53089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53090       };
53091     } catch (std::exception& e) {
53092       {
53093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53094       };
53095     } catch (Dali::DaliException e) {
53096       {
53097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53098       };
53099     } catch (...) {
53100       {
53101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53102       };
53103     }
53104   }
53105
53106   jresult = (void *)result;
53107   return jresult;
53108 }
53109
53110
53111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53112   void * jresult ;
53113   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53114   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53115   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53116
53117   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53118   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53119   if (!arg2) {
53120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53121     return 0;
53122   }
53123   {
53124     try {
53125       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
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 (Dali::DaliException e) {
53135       {
53136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53137       };
53138     } catch (...) {
53139       {
53140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53141       };
53142     }
53143   }
53144
53145   jresult = (void *)result;
53146   return jresult;
53147 }
53148
53149
53150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53151   void * jresult ;
53152   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53153   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53154
53155   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53156   {
53157     try {
53158       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53159     } catch (std::out_of_range& e) {
53160       {
53161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53162       };
53163     } catch (std::exception& e) {
53164       {
53165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53166       };
53167     } catch (Dali::DaliException e) {
53168       {
53169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53170       };
53171     } catch (...) {
53172       {
53173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53174       };
53175     }
53176   }
53177
53178   jresult = (void *)result;
53179   return jresult;
53180 }
53181
53182
53183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53184   void * jresult ;
53185   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53186   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53187
53188   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53189   {
53190     try {
53191       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53192     } catch (std::out_of_range& e) {
53193       {
53194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53195       };
53196     } catch (std::exception& e) {
53197       {
53198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53199       };
53200     } catch (Dali::DaliException e) {
53201       {
53202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53203       };
53204     } catch (...) {
53205       {
53206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53207       };
53208     }
53209   }
53210
53211   jresult = (void *)result;
53212   return jresult;
53213 }
53214
53215
53216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53217   void * jresult ;
53218   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53219   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53220   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53221
53222   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53223   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53224   {
53225     try {
53226       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53227     } catch (std::out_of_range& e) {
53228       {
53229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53230       };
53231     } catch (std::exception& e) {
53232       {
53233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53234       };
53235     } catch (Dali::DaliException e) {
53236       {
53237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53238       };
53239     } catch (...) {
53240       {
53241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53242       };
53243     }
53244   }
53245
53246   jresult = (void *)result;
53247   return jresult;
53248 }
53249
53250
53251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53252   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53253   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53254
53255   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53256   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53257   if (!arg2) {
53258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53259     return ;
53260   }
53261   {
53262     try {
53263       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53264     } catch (std::out_of_range& e) {
53265       {
53266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53267       };
53268     } catch (std::exception& e) {
53269       {
53270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53271       };
53272     } catch (Dali::DaliException e) {
53273       {
53274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53275       };
53276     } catch (...) {
53277       {
53278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53279       };
53280     }
53281   }
53282
53283 }
53284
53285
53286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53287   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53288   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53289   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53290
53291   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53292   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53293   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53294   if (!arg3) {
53295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53296     return ;
53297   }
53298   {
53299     try {
53300       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53301     } catch (std::out_of_range& e) {
53302       {
53303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53304       };
53305     } catch (std::exception& e) {
53306       {
53307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53308       };
53309     } catch (Dali::DaliException e) {
53310       {
53311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53312       };
53313     } catch (...) {
53314       {
53315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53316       };
53317     }
53318   }
53319
53320 }
53321
53322
53323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53324   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53325   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53326   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53327   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53328
53329   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53330   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53331   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53332   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53333   {
53334     try {
53335       (arg1)->Insert(arg2,arg3,arg4);
53336     } catch (std::out_of_range& e) {
53337       {
53338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53339       };
53340     } catch (std::exception& e) {
53341       {
53342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53343       };
53344     } catch (Dali::DaliException e) {
53345       {
53346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53347       };
53348     } catch (...) {
53349       {
53350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53351       };
53352     }
53353   }
53354
53355 }
53356
53357
53358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53359   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53360   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53361
53362   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53363   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53364   {
53365     try {
53366       (arg1)->Reserve(arg2);
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 (Dali::DaliException e) {
53376       {
53377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53378       };
53379     } catch (...) {
53380       {
53381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53382       };
53383     }
53384   }
53385
53386 }
53387
53388
53389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53390   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53391   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53392
53393   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53394   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53395   {
53396     try {
53397       (arg1)->Resize(arg2);
53398     } catch (std::out_of_range& e) {
53399       {
53400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53401       };
53402     } catch (std::exception& e) {
53403       {
53404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53405       };
53406     } catch (Dali::DaliException e) {
53407       {
53408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53409       };
53410     } catch (...) {
53411       {
53412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53413       };
53414     }
53415   }
53416
53417 }
53418
53419
53420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53421   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53422   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53423   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53424
53425   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53426   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53427   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53428   if (!arg3) {
53429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53430     return ;
53431   }
53432   {
53433     try {
53434       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53435     } catch (std::out_of_range& e) {
53436       {
53437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53438       };
53439     } catch (std::exception& e) {
53440       {
53441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53442       };
53443     } catch (Dali::DaliException e) {
53444       {
53445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53446       };
53447     } catch (...) {
53448       {
53449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53450       };
53451     }
53452   }
53453
53454 }
53455
53456
53457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53458   void * jresult ;
53459   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53460   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53461   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53462
53463   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53464   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53465   {
53466     try {
53467       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53468     } catch (std::out_of_range& e) {
53469       {
53470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53471       };
53472     } catch (std::exception& e) {
53473       {
53474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53475       };
53476     } catch (Dali::DaliException e) {
53477       {
53478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53479       };
53480     } catch (...) {
53481       {
53482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53483       };
53484     }
53485   }
53486
53487   jresult = (void *)result;
53488   return jresult;
53489 }
53490
53491
53492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53493   void * jresult ;
53494   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53495   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53496   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53497   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53498
53499   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53500   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53501   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53502   {
53503     try {
53504       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53505     } catch (std::out_of_range& e) {
53506       {
53507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53508       };
53509     } catch (std::exception& e) {
53510       {
53511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53512       };
53513     } catch (Dali::DaliException e) {
53514       {
53515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53516       };
53517     } catch (...) {
53518       {
53519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53520       };
53521     }
53522   }
53523
53524   jresult = (void *)result;
53525   return jresult;
53526 }
53527
53528
53529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53530   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53531   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53532
53533   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53534   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53535   {
53536     try {
53537       (arg1)->Remove(arg2);
53538     } catch (std::out_of_range& e) {
53539       {
53540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53541       };
53542     } catch (std::exception& e) {
53543       {
53544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53545       };
53546     } catch (Dali::DaliException e) {
53547       {
53548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53549       };
53550     } catch (...) {
53551       {
53552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53553       };
53554     }
53555   }
53556
53557 }
53558
53559
53560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53561   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53562   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53563
53564   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53565   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53566   if (!arg2) {
53567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53568     return ;
53569   }
53570   {
53571     try {
53572       (arg1)->Swap(*arg2);
53573     } catch (std::out_of_range& e) {
53574       {
53575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53576       };
53577     } catch (std::exception& e) {
53578       {
53579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53580       };
53581     } catch (Dali::DaliException e) {
53582       {
53583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53584       };
53585     } catch (...) {
53586       {
53587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53588       };
53589     }
53590   }
53591
53592 }
53593
53594
53595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53596   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53597
53598   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53599   {
53600     try {
53601       (arg1)->Clear();
53602     } catch (std::out_of_range& e) {
53603       {
53604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53605       };
53606     } catch (std::exception& e) {
53607       {
53608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53609       };
53610     } catch (Dali::DaliException e) {
53611       {
53612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53613       };
53614     } catch (...) {
53615       {
53616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53617       };
53618     }
53619   }
53620
53621 }
53622
53623
53624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53625   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53626
53627   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53628   {
53629     try {
53630       (arg1)->Release();
53631     } catch (std::out_of_range& e) {
53632       {
53633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53634       };
53635     } catch (std::exception& e) {
53636       {
53637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53638       };
53639     } catch (Dali::DaliException e) {
53640       {
53641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53642       };
53643     } catch (...) {
53644       {
53645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53646       };
53647     }
53648   }
53649
53650 }
53651
53652
53653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53654   void * jresult ;
53655   Dali::Signal< void () > *result = 0 ;
53656
53657   {
53658     try {
53659       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53660     } catch (std::out_of_range& e) {
53661       {
53662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53663       };
53664     } catch (std::exception& e) {
53665       {
53666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53667       };
53668     } catch (Dali::DaliException e) {
53669       {
53670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53671       };
53672     } catch (...) {
53673       {
53674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53675       };
53676     }
53677   }
53678
53679   jresult = (void *)result;
53680   return jresult;
53681 }
53682
53683
53684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53685   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53686
53687   arg1 = (Dali::Signal< void () > *)jarg1;
53688   {
53689     try {
53690       delete arg1;
53691     } catch (std::out_of_range& e) {
53692       {
53693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53694       };
53695     } catch (std::exception& e) {
53696       {
53697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53698       };
53699     } catch (Dali::DaliException e) {
53700       {
53701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53702       };
53703     } catch (...) {
53704       {
53705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53706       };
53707     }
53708   }
53709
53710 }
53711
53712
53713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53714   unsigned int jresult ;
53715   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53716   bool result;
53717
53718   arg1 = (Dali::Signal< void () > *)jarg1;
53719   {
53720     try {
53721       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53722     } catch (std::out_of_range& e) {
53723       {
53724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53725       };
53726     } catch (std::exception& e) {
53727       {
53728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53729       };
53730     } catch (Dali::DaliException e) {
53731       {
53732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53733       };
53734     } catch (...) {
53735       {
53736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53737       };
53738     }
53739   }
53740
53741   jresult = result;
53742   return jresult;
53743 }
53744
53745
53746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53747   unsigned long jresult ;
53748   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53749   std::size_t result;
53750
53751   arg1 = (Dali::Signal< void () > *)jarg1;
53752   {
53753     try {
53754       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53755     } catch (std::out_of_range& e) {
53756       {
53757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53758       };
53759     } catch (std::exception& e) {
53760       {
53761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53762       };
53763     } catch (Dali::DaliException e) {
53764       {
53765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53766       };
53767     } catch (...) {
53768       {
53769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53770       };
53771     }
53772   }
53773
53774   jresult = (unsigned long)result;
53775   return jresult;
53776 }
53777
53778
53779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53780   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53781   void (*arg2)() = (void (*)()) 0 ;
53782
53783   arg1 = (Dali::Signal< void () > *)jarg1;
53784   arg2 = (void (*)())jarg2;
53785   {
53786     try {
53787       (arg1)->Connect(arg2);
53788     } catch (std::out_of_range& e) {
53789       {
53790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53791       };
53792     } catch (std::exception& e) {
53793       {
53794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53795       };
53796     } catch (Dali::DaliException e) {
53797       {
53798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53799       };
53800     } catch (...) {
53801       {
53802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53803       };
53804     }
53805   }
53806
53807 }
53808
53809
53810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53811   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53812   void (*arg2)() = (void (*)()) 0 ;
53813
53814   arg1 = (Dali::Signal< void () > *)jarg1;
53815   arg2 = (void (*)())jarg2;
53816   {
53817     try {
53818       (arg1)->Disconnect(arg2);
53819     } catch (std::out_of_range& e) {
53820       {
53821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53822       };
53823     } catch (std::exception& e) {
53824       {
53825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53826       };
53827     } catch (Dali::DaliException e) {
53828       {
53829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53830       };
53831     } catch (...) {
53832       {
53833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53834       };
53835     }
53836   }
53837
53838 }
53839
53840
53841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53842   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53843   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53844   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53845
53846   arg1 = (Dali::Signal< void () > *)jarg1;
53847   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53848   arg3 = (Dali::FunctorDelegate *)jarg3;
53849   {
53850     try {
53851       (arg1)->Connect(arg2,arg3);
53852     } catch (std::out_of_range& e) {
53853       {
53854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53855       };
53856     } catch (std::exception& e) {
53857       {
53858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53859       };
53860     } catch (Dali::DaliException e) {
53861       {
53862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53863       };
53864     } catch (...) {
53865       {
53866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53867       };
53868     }
53869   }
53870
53871 }
53872
53873
53874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53875   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53876
53877   arg1 = (Dali::Signal< void () > *)jarg1;
53878   {
53879     try {
53880       (arg1)->Emit();
53881     } catch (std::out_of_range& e) {
53882       {
53883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53884       };
53885     } catch (std::exception& e) {
53886       {
53887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53888       };
53889     } catch (Dali::DaliException e) {
53890       {
53891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53892       };
53893     } catch (...) {
53894       {
53895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53896       };
53897     }
53898   }
53899
53900 }
53901
53902
53903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53904   unsigned int jresult ;
53905   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53906   bool result;
53907
53908   arg1 = (Dali::Signal< void (float) > *)jarg1;
53909   {
53910     try {
53911       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53912     } catch (std::out_of_range& e) {
53913       {
53914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53915       };
53916     } catch (std::exception& e) {
53917       {
53918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53919       };
53920     } catch (Dali::DaliException e) {
53921       {
53922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53923       };
53924     } catch (...) {
53925       {
53926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53927       };
53928     }
53929   }
53930
53931   jresult = result;
53932   return jresult;
53933 }
53934
53935
53936 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53937   unsigned long jresult ;
53938   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53939   std::size_t result;
53940
53941   arg1 = (Dali::Signal< void (float) > *)jarg1;
53942   {
53943     try {
53944       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53945     } catch (std::out_of_range& e) {
53946       {
53947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53948       };
53949     } catch (std::exception& e) {
53950       {
53951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53952       };
53953     } catch (Dali::DaliException e) {
53954       {
53955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53956       };
53957     } catch (...) {
53958       {
53959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53960       };
53961     }
53962   }
53963
53964   jresult = (unsigned long)result;
53965   return jresult;
53966 }
53967
53968
53969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53970   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53971   void (*arg2)(float) = (void (*)(float)) 0 ;
53972
53973   arg1 = (Dali::Signal< void (float) > *)jarg1;
53974   arg2 = (void (*)(float))jarg2;
53975   {
53976     try {
53977       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53978     } catch (std::out_of_range& e) {
53979       {
53980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53981       };
53982     } catch (std::exception& e) {
53983       {
53984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53985       };
53986     } catch (Dali::DaliException e) {
53987       {
53988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53989       };
53990     } catch (...) {
53991       {
53992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53993       };
53994     }
53995   }
53996
53997 }
53998
53999
54000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54001   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54002   void (*arg2)(float) = (void (*)(float)) 0 ;
54003
54004   arg1 = (Dali::Signal< void (float) > *)jarg1;
54005   arg2 = (void (*)(float))jarg2;
54006   {
54007     try {
54008       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54009     } catch (std::out_of_range& e) {
54010       {
54011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54012       };
54013     } catch (std::exception& e) {
54014       {
54015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54016       };
54017     } catch (Dali::DaliException e) {
54018       {
54019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54020       };
54021     } catch (...) {
54022       {
54023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54024       };
54025     }
54026   }
54027
54028 }
54029
54030
54031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54032   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54033   float arg2 ;
54034
54035   arg1 = (Dali::Signal< void (float) > *)jarg1;
54036   arg2 = (float)jarg2;
54037   {
54038     try {
54039       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54040     } catch (std::out_of_range& e) {
54041       {
54042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54043       };
54044     } catch (std::exception& e) {
54045       {
54046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54047       };
54048     } catch (Dali::DaliException e) {
54049       {
54050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54051       };
54052     } catch (...) {
54053       {
54054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54055       };
54056     }
54057   }
54058
54059 }
54060
54061
54062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54063   void * jresult ;
54064   Dali::Signal< void (float) > *result = 0 ;
54065
54066   {
54067     try {
54068       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54069     } catch (std::out_of_range& e) {
54070       {
54071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54072       };
54073     } catch (std::exception& e) {
54074       {
54075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54076       };
54077     } catch (Dali::DaliException e) {
54078       {
54079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54080       };
54081     } catch (...) {
54082       {
54083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54084       };
54085     }
54086   }
54087
54088   jresult = (void *)result;
54089   return jresult;
54090 }
54091
54092
54093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54094   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54095
54096   arg1 = (Dali::Signal< void (float) > *)jarg1;
54097   {
54098     try {
54099       delete arg1;
54100     } catch (std::out_of_range& e) {
54101       {
54102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54103       };
54104     } catch (std::exception& e) {
54105       {
54106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54107       };
54108     } catch (Dali::DaliException e) {
54109       {
54110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54111       };
54112     } catch (...) {
54113       {
54114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54115       };
54116     }
54117   }
54118
54119 }
54120
54121
54122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54123   unsigned int jresult ;
54124   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54125   bool result;
54126
54127   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54128   {
54129     try {
54130       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54131     } catch (std::out_of_range& e) {
54132       {
54133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54134       };
54135     } catch (std::exception& e) {
54136       {
54137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54138       };
54139     } catch (Dali::DaliException e) {
54140       {
54141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54142       };
54143     } catch (...) {
54144       {
54145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54146       };
54147     }
54148   }
54149
54150   jresult = result;
54151   return jresult;
54152 }
54153
54154
54155 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54156   unsigned long jresult ;
54157   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54158   std::size_t result;
54159
54160   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54161   {
54162     try {
54163       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54164     } catch (std::out_of_range& e) {
54165       {
54166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54167       };
54168     } catch (std::exception& e) {
54169       {
54170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54171       };
54172     } catch (Dali::DaliException e) {
54173       {
54174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54175       };
54176     } catch (...) {
54177       {
54178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54179       };
54180     }
54181   }
54182
54183   jresult = (unsigned long)result;
54184   return jresult;
54185 }
54186
54187
54188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54189   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54190   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54191
54192   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54193   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54194   {
54195     try {
54196       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54197     } catch (std::out_of_range& e) {
54198       {
54199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54200       };
54201     } catch (std::exception& e) {
54202       {
54203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54204       };
54205     } catch (Dali::DaliException e) {
54206       {
54207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54208       };
54209     } catch (...) {
54210       {
54211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54212       };
54213     }
54214   }
54215
54216 }
54217
54218
54219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54220   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54221   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54222
54223   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54224   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54225   {
54226     try {
54227       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54228     } catch (std::out_of_range& e) {
54229       {
54230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54231       };
54232     } catch (std::exception& e) {
54233       {
54234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54235       };
54236     } catch (Dali::DaliException e) {
54237       {
54238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54239       };
54240     } catch (...) {
54241       {
54242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54243       };
54244     }
54245   }
54246
54247 }
54248
54249
54250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54251   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54252   Dali::BaseHandle arg2 ;
54253   Dali::BaseHandle *argp2 ;
54254
54255   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54256   argp2 = (Dali::BaseHandle *)jarg2;
54257   if (!argp2) {
54258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54259     return ;
54260   }
54261   arg2 = *argp2;
54262   {
54263     try {
54264       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54265     } catch (std::out_of_range& e) {
54266       {
54267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54268       };
54269     } catch (std::exception& e) {
54270       {
54271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54272       };
54273     } catch (Dali::DaliException e) {
54274       {
54275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54276       };
54277     } catch (...) {
54278       {
54279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54280       };
54281     }
54282   }
54283
54284 }
54285
54286
54287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54288   void * jresult ;
54289   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54290
54291   {
54292     try {
54293       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54294     } catch (std::out_of_range& e) {
54295       {
54296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54297       };
54298     } catch (std::exception& e) {
54299       {
54300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54301       };
54302     } catch (Dali::DaliException e) {
54303       {
54304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54305       };
54306     } catch (...) {
54307       {
54308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54309       };
54310     }
54311   }
54312
54313   jresult = (void *)result;
54314   return jresult;
54315 }
54316
54317
54318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54319   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54320
54321   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54322   {
54323     try {
54324       delete arg1;
54325     } catch (std::out_of_range& e) {
54326       {
54327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54328       };
54329     } catch (std::exception& e) {
54330       {
54331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54332       };
54333     } catch (Dali::DaliException e) {
54334       {
54335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54336       };
54337     } catch (...) {
54338       {
54339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54340       };
54341     }
54342   }
54343
54344 }
54345
54346
54347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54348   unsigned int jresult ;
54349   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54350   bool result;
54351
54352   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54353   {
54354     try {
54355       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54356     } catch (std::out_of_range& e) {
54357       {
54358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54359       };
54360     } catch (std::exception& e) {
54361       {
54362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54363       };
54364     } catch (Dali::DaliException e) {
54365       {
54366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54367       };
54368     } catch (...) {
54369       {
54370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54371       };
54372     }
54373   }
54374
54375   jresult = result;
54376   return jresult;
54377 }
54378
54379
54380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54381   unsigned long jresult ;
54382   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54383   std::size_t result;
54384
54385   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54386   {
54387     try {
54388       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54389     } catch (std::out_of_range& e) {
54390       {
54391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54392       };
54393     } catch (std::exception& e) {
54394       {
54395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54396       };
54397     } catch (Dali::DaliException e) {
54398       {
54399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54400       };
54401     } catch (...) {
54402       {
54403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54404       };
54405     }
54406   }
54407
54408   jresult = (unsigned long)result;
54409   return jresult;
54410 }
54411
54412
54413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54414   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54415   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54416
54417   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54418   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54419   {
54420     try {
54421       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54422     } catch (std::out_of_range& e) {
54423       {
54424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54425       };
54426     } catch (std::exception& e) {
54427       {
54428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54429       };
54430     } catch (Dali::DaliException e) {
54431       {
54432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54433       };
54434     } catch (...) {
54435       {
54436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54437       };
54438     }
54439   }
54440
54441 }
54442
54443
54444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54445   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54446   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54447
54448   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54449   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54450   {
54451     try {
54452       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54453     } catch (std::out_of_range& e) {
54454       {
54455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54456       };
54457     } catch (std::exception& e) {
54458       {
54459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54460       };
54461     } catch (Dali::DaliException e) {
54462       {
54463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54464       };
54465     } catch (...) {
54466       {
54467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54468       };
54469     }
54470   }
54471
54472 }
54473
54474
54475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54476   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54477   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54478
54479   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54480   arg2 = (Dali::RefObject *)jarg2;
54481   {
54482     try {
54483       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54484     } catch (std::out_of_range& e) {
54485       {
54486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54487       };
54488     } catch (std::exception& e) {
54489       {
54490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54491       };
54492     } catch (Dali::DaliException e) {
54493       {
54494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54495       };
54496     } catch (...) {
54497       {
54498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54499       };
54500     }
54501   }
54502
54503 }
54504
54505
54506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54507   void * jresult ;
54508   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54509
54510   {
54511     try {
54512       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54513     } catch (std::out_of_range& e) {
54514       {
54515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54516       };
54517     } catch (std::exception& e) {
54518       {
54519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54520       };
54521     } catch (Dali::DaliException e) {
54522       {
54523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54524       };
54525     } catch (...) {
54526       {
54527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54528       };
54529     }
54530   }
54531
54532   jresult = (void *)result;
54533   return jresult;
54534 }
54535
54536
54537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54538   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54539
54540   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54541   {
54542     try {
54543       delete arg1;
54544     } catch (std::out_of_range& e) {
54545       {
54546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54547       };
54548     } catch (std::exception& e) {
54549       {
54550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54551       };
54552     } catch (Dali::DaliException e) {
54553       {
54554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54555       };
54556     } catch (...) {
54557       {
54558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54559       };
54560     }
54561   }
54562
54563 }
54564
54565
54566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54567   unsigned int jresult ;
54568   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54569   bool result;
54570
54571   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54572   {
54573     try {
54574       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54575     } catch (std::out_of_range& e) {
54576       {
54577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54578       };
54579     } catch (std::exception& e) {
54580       {
54581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54582       };
54583     } catch (Dali::DaliException e) {
54584       {
54585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54586       };
54587     } catch (...) {
54588       {
54589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54590       };
54591     }
54592   }
54593
54594   jresult = result;
54595   return jresult;
54596 }
54597
54598
54599 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54600   unsigned long jresult ;
54601   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54602   std::size_t result;
54603
54604   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54605   {
54606     try {
54607       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54608     } catch (std::out_of_range& e) {
54609       {
54610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54611       };
54612     } catch (std::exception& e) {
54613       {
54614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54615       };
54616     } catch (Dali::DaliException e) {
54617       {
54618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54619       };
54620     } catch (...) {
54621       {
54622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54623       };
54624     }
54625   }
54626
54627   jresult = (unsigned long)result;
54628   return jresult;
54629 }
54630
54631
54632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54633   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54634   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54635
54636   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54637   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54638   {
54639     try {
54640       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54641     } catch (std::out_of_range& e) {
54642       {
54643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54644       };
54645     } catch (std::exception& e) {
54646       {
54647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54648       };
54649     } catch (Dali::DaliException e) {
54650       {
54651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54652       };
54653     } catch (...) {
54654       {
54655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54656       };
54657     }
54658   }
54659
54660 }
54661
54662
54663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54664   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54665   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54666
54667   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54668   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54669   {
54670     try {
54671       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54672     } catch (std::out_of_range& e) {
54673       {
54674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54675       };
54676     } catch (std::exception& e) {
54677       {
54678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54679       };
54680     } catch (Dali::DaliException e) {
54681       {
54682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54683       };
54684     } catch (...) {
54685       {
54686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54687       };
54688     }
54689   }
54690
54691 }
54692
54693
54694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54695   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54696   Dali::PropertyNotification *arg2 = 0 ;
54697
54698   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54699   arg2 = (Dali::PropertyNotification *)jarg2;
54700   if (!arg2) {
54701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54702     return ;
54703   }
54704   {
54705     try {
54706       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54707     } catch (std::out_of_range& e) {
54708       {
54709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54710       };
54711     } catch (std::exception& e) {
54712       {
54713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54714       };
54715     } catch (Dali::DaliException e) {
54716       {
54717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54718       };
54719     } catch (...) {
54720       {
54721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54722       };
54723     }
54724   }
54725
54726 }
54727
54728
54729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54730   void * jresult ;
54731   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54732
54733   {
54734     try {
54735       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54736     } catch (std::out_of_range& e) {
54737       {
54738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54739       };
54740     } catch (std::exception& e) {
54741       {
54742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54743       };
54744     } catch (Dali::DaliException e) {
54745       {
54746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54747       };
54748     } catch (...) {
54749       {
54750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54751       };
54752     }
54753   }
54754
54755   jresult = (void *)result;
54756   return jresult;
54757 }
54758
54759
54760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54761   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54762
54763   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54764   {
54765     try {
54766       delete arg1;
54767     } catch (std::out_of_range& e) {
54768       {
54769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54770       };
54771     } catch (std::exception& e) {
54772       {
54773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54774       };
54775     } catch (Dali::DaliException e) {
54776       {
54777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54778       };
54779     } catch (...) {
54780       {
54781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54782       };
54783     }
54784   }
54785
54786 }
54787
54788
54789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54790   unsigned int jresult ;
54791   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54792   bool result;
54793
54794   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54795   {
54796     try {
54797       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54798     } catch (std::out_of_range& e) {
54799       {
54800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54801       };
54802     } catch (std::exception& e) {
54803       {
54804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54805       };
54806     } catch (Dali::DaliException e) {
54807       {
54808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54809       };
54810     } catch (...) {
54811       {
54812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54813       };
54814     }
54815   }
54816
54817   jresult = result;
54818   return jresult;
54819 }
54820
54821
54822 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54823   unsigned long jresult ;
54824   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54825   std::size_t result;
54826
54827   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54828   {
54829     try {
54830       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54831     } catch (std::out_of_range& e) {
54832       {
54833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54834       };
54835     } catch (std::exception& e) {
54836       {
54837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54838       };
54839     } catch (Dali::DaliException e) {
54840       {
54841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54842       };
54843     } catch (...) {
54844       {
54845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54846       };
54847     }
54848   }
54849
54850   jresult = (unsigned long)result;
54851   return jresult;
54852 }
54853
54854
54855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54856   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54857   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54858
54859   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54860   arg2 = (void (*)(Dali::Image))jarg2;
54861   {
54862     try {
54863       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54864     } catch (std::out_of_range& e) {
54865       {
54866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54867       };
54868     } catch (std::exception& e) {
54869       {
54870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54871       };
54872     } catch (Dali::DaliException e) {
54873       {
54874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54875       };
54876     } catch (...) {
54877       {
54878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54879       };
54880     }
54881   }
54882
54883 }
54884
54885
54886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54887   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54888   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54889
54890   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54891   arg2 = (void (*)(Dali::Image))jarg2;
54892   {
54893     try {
54894       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54895     } catch (std::out_of_range& e) {
54896       {
54897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54898       };
54899     } catch (std::exception& e) {
54900       {
54901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54902       };
54903     } catch (Dali::DaliException e) {
54904       {
54905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54906       };
54907     } catch (...) {
54908       {
54909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54910       };
54911     }
54912   }
54913
54914 }
54915
54916
54917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54918   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54919   Dali::Image arg2 ;
54920   Dali::Image *argp2 ;
54921
54922   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54923   argp2 = (Dali::Image *)jarg2;
54924   if (!argp2) {
54925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54926     return ;
54927   }
54928   arg2 = *argp2;
54929   {
54930     try {
54931       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54932     } catch (std::out_of_range& e) {
54933       {
54934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54935       };
54936     } catch (std::exception& e) {
54937       {
54938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54939       };
54940     } catch (Dali::DaliException e) {
54941       {
54942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54943       };
54944     } catch (...) {
54945       {
54946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54947       };
54948     }
54949   }
54950
54951 }
54952
54953
54954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54955   void * jresult ;
54956   Dali::Signal< void (Dali::Image) > *result = 0 ;
54957
54958   {
54959     try {
54960       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54961     } catch (std::out_of_range& e) {
54962       {
54963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54964       };
54965     } catch (std::exception& e) {
54966       {
54967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54968       };
54969     } catch (Dali::DaliException e) {
54970       {
54971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54972       };
54973     } catch (...) {
54974       {
54975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54976       };
54977     }
54978   }
54979
54980   jresult = (void *)result;
54981   return jresult;
54982 }
54983
54984
54985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54986   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54987
54988   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54989   {
54990     try {
54991       delete arg1;
54992     } catch (std::out_of_range& e) {
54993       {
54994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54995       };
54996     } catch (std::exception& e) {
54997       {
54998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54999       };
55000     } catch (Dali::DaliException e) {
55001       {
55002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55003       };
55004     } catch (...) {
55005       {
55006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55007       };
55008     }
55009   }
55010
55011 }
55012
55013
55014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55015   void * jresult ;
55016   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55017
55018   {
55019     try {
55020       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55021     } catch (std::out_of_range& e) {
55022       {
55023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55024       };
55025     } catch (std::exception& e) {
55026       {
55027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55028       };
55029     } catch (Dali::DaliException e) {
55030       {
55031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55032       };
55033     } catch (...) {
55034       {
55035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55036       };
55037     }
55038   }
55039
55040   jresult = (void *)result;
55041   return jresult;
55042 }
55043
55044
55045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55046   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55047
55048   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55049   {
55050     try {
55051       delete arg1;
55052     } catch (std::out_of_range& e) {
55053       {
55054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55055       };
55056     } catch (std::exception& e) {
55057       {
55058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55059       };
55060     } catch (Dali::DaliException e) {
55061       {
55062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55063       };
55064     } catch (...) {
55065       {
55066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55067       };
55068     }
55069   }
55070
55071 }
55072
55073
55074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55075   unsigned int jresult ;
55076   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55077   bool result;
55078
55079   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55080   {
55081     try {
55082       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);
55083     } catch (std::out_of_range& e) {
55084       {
55085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55086       };
55087     } catch (std::exception& e) {
55088       {
55089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55090       };
55091     } catch (Dali::DaliException e) {
55092       {
55093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55094       };
55095     } catch (...) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55098       };
55099     }
55100   }
55101
55102   jresult = result;
55103   return jresult;
55104 }
55105
55106
55107 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55108   unsigned long jresult ;
55109   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55110   std::size_t result;
55111
55112   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55113   {
55114     try {
55115       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);
55116     } catch (std::out_of_range& e) {
55117       {
55118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55119       };
55120     } catch (std::exception& e) {
55121       {
55122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55123       };
55124     } catch (Dali::DaliException e) {
55125       {
55126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55127       };
55128     } catch (...) {
55129       {
55130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55131       };
55132     }
55133   }
55134
55135   jresult = (unsigned long)result;
55136   return jresult;
55137 }
55138
55139
55140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55141   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55142   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55143
55144   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55145   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55146   {
55147     try {
55148       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55149     } catch (std::out_of_range& e) {
55150       {
55151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55152       };
55153     } catch (std::exception& e) {
55154       {
55155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55156       };
55157     } catch (Dali::DaliException e) {
55158       {
55159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55160       };
55161     } catch (...) {
55162       {
55163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55164       };
55165     }
55166   }
55167
55168 }
55169
55170
55171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55172   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55173   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55174
55175   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55176   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55177   {
55178     try {
55179       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55180     } catch (std::out_of_range& e) {
55181       {
55182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55183       };
55184     } catch (std::exception& e) {
55185       {
55186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55187       };
55188     } catch (Dali::DaliException e) {
55189       {
55190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55191       };
55192     } catch (...) {
55193       {
55194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55195       };
55196     }
55197   }
55198
55199 }
55200
55201
55202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55203   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55204   Dali::Actor arg2 ;
55205   Dali::LongPressGesture *arg3 = 0 ;
55206   Dali::Actor *argp2 ;
55207
55208   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55209   argp2 = (Dali::Actor *)jarg2;
55210   if (!argp2) {
55211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55212     return ;
55213   }
55214   arg2 = *argp2;
55215   arg3 = (Dali::LongPressGesture *)jarg3;
55216   if (!arg3) {
55217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55218     return ;
55219   }
55220   {
55221     try {
55222       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55223     } catch (std::out_of_range& e) {
55224       {
55225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55226       };
55227     } catch (std::exception& e) {
55228       {
55229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55230       };
55231     } catch (Dali::DaliException e) {
55232       {
55233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55234       };
55235     } catch (...) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55238       };
55239     }
55240   }
55241
55242 }
55243
55244
55245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55246   void * jresult ;
55247   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55248
55249   {
55250     try {
55251       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55252     } catch (std::out_of_range& e) {
55253       {
55254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55255       };
55256     } catch (std::exception& e) {
55257       {
55258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55259       };
55260     } catch (Dali::DaliException e) {
55261       {
55262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55263       };
55264     } catch (...) {
55265       {
55266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55267       };
55268     }
55269   }
55270
55271   jresult = (void *)result;
55272   return jresult;
55273 }
55274
55275
55276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55277   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55278
55279   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55280   {
55281     try {
55282       delete arg1;
55283     } catch (std::out_of_range& e) {
55284       {
55285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55286       };
55287     } catch (std::exception& e) {
55288       {
55289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55290       };
55291     } catch (Dali::DaliException e) {
55292       {
55293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55294       };
55295     } catch (...) {
55296       {
55297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55298       };
55299     }
55300   }
55301
55302 }
55303
55304
55305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55306   unsigned int jresult ;
55307   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55308   bool result;
55309
55310   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55311   {
55312     try {
55313       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);
55314     } catch (std::out_of_range& e) {
55315       {
55316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55317       };
55318     } catch (std::exception& e) {
55319       {
55320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55321       };
55322     } catch (Dali::DaliException e) {
55323       {
55324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55325       };
55326     } catch (...) {
55327       {
55328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55329       };
55330     }
55331   }
55332
55333   jresult = result;
55334   return jresult;
55335 }
55336
55337
55338 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55339   unsigned long jresult ;
55340   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55341   std::size_t result;
55342
55343   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55344   {
55345     try {
55346       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);
55347     } catch (std::out_of_range& e) {
55348       {
55349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55350       };
55351     } catch (std::exception& e) {
55352       {
55353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55354       };
55355     } catch (Dali::DaliException e) {
55356       {
55357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55358       };
55359     } catch (...) {
55360       {
55361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55362       };
55363     }
55364   }
55365
55366   jresult = (unsigned long)result;
55367   return jresult;
55368 }
55369
55370
55371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55372   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55373   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55374
55375   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55376   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55377   {
55378     try {
55379       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
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 (Dali::DaliException e) {
55389       {
55390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55391       };
55392     } catch (...) {
55393       {
55394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55395       };
55396     }
55397   }
55398
55399 }
55400
55401
55402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55403   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55404   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55405
55406   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55407   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55408   {
55409     try {
55410       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55411     } catch (std::out_of_range& e) {
55412       {
55413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55414       };
55415     } catch (std::exception& e) {
55416       {
55417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55418       };
55419     } catch (Dali::DaliException e) {
55420       {
55421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55422       };
55423     } catch (...) {
55424       {
55425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55426       };
55427     }
55428   }
55429
55430 }
55431
55432
55433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55434   unsigned int jresult ;
55435   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55436   Dali::Actor arg2 ;
55437   Dali::TouchData *arg3 = 0 ;
55438   Dali::Actor *argp2 ;
55439   bool result;
55440
55441   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55442   argp2 = (Dali::Actor *)jarg2;
55443   if (!argp2) {
55444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55445     return 0;
55446   }
55447   arg2 = *argp2;
55448   arg3 = (Dali::TouchData *)jarg3;
55449   if (!arg3) {
55450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55451     return 0;
55452   }
55453   {
55454     try {
55455       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55456     } catch (std::out_of_range& e) {
55457       {
55458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55459       };
55460     } catch (std::exception& e) {
55461       {
55462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55463       };
55464     } catch (Dali::DaliException e) {
55465       {
55466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55467       };
55468     } catch (...) {
55469       {
55470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55471       };
55472     }
55473   }
55474
55475   jresult = result;
55476   return jresult;
55477 }
55478
55479
55480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55481   void * jresult ;
55482   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55483
55484   {
55485     try {
55486       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55487     } catch (std::out_of_range& e) {
55488       {
55489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55490       };
55491     } catch (std::exception& e) {
55492       {
55493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55494       };
55495     } catch (Dali::DaliException e) {
55496       {
55497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55498       };
55499     } catch (...) {
55500       {
55501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55502       };
55503     }
55504   }
55505
55506   jresult = (void *)result;
55507   return jresult;
55508 }
55509
55510
55511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55512   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55513
55514   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55515   {
55516     try {
55517       delete arg1;
55518     } catch (std::out_of_range& e) {
55519       {
55520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55521       };
55522     } catch (std::exception& e) {
55523       {
55524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55525       };
55526     } catch (Dali::DaliException e) {
55527       {
55528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55529       };
55530     } catch (...) {
55531       {
55532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55533       };
55534     }
55535   }
55536
55537 }
55538
55539
55540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55541   unsigned int jresult ;
55542   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55543   bool result;
55544
55545   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55546   {
55547     try {
55548       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);
55549     } catch (std::out_of_range& e) {
55550       {
55551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55552       };
55553     } catch (std::exception& e) {
55554       {
55555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55556       };
55557     } catch (Dali::DaliException e) {
55558       {
55559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55560       };
55561     } catch (...) {
55562       {
55563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55564       };
55565     }
55566   }
55567
55568   jresult = result;
55569   return jresult;
55570 }
55571
55572
55573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55574   unsigned long jresult ;
55575   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55576   std::size_t result;
55577
55578   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55579   {
55580     try {
55581       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);
55582     } catch (std::out_of_range& e) {
55583       {
55584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55585       };
55586     } catch (std::exception& e) {
55587       {
55588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55589       };
55590     } catch (Dali::DaliException e) {
55591       {
55592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55593       };
55594     } catch (...) {
55595       {
55596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55597       };
55598     }
55599   }
55600
55601   jresult = (unsigned long)result;
55602   return jresult;
55603 }
55604
55605
55606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55607   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55608   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55609
55610   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55611   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55612   {
55613     try {
55614       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55615     } catch (std::out_of_range& e) {
55616       {
55617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55618       };
55619     } catch (std::exception& e) {
55620       {
55621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55622       };
55623     } catch (Dali::DaliException e) {
55624       {
55625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55626       };
55627     } catch (...) {
55628       {
55629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55630       };
55631     }
55632   }
55633
55634 }
55635
55636
55637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55638   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55639   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55640
55641   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55642   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55643   {
55644     try {
55645       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55646     } catch (std::out_of_range& e) {
55647       {
55648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55649       };
55650     } catch (std::exception& e) {
55651       {
55652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55653       };
55654     } catch (Dali::DaliException e) {
55655       {
55656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55657       };
55658     } catch (...) {
55659       {
55660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55661       };
55662     }
55663   }
55664
55665 }
55666
55667
55668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55669   unsigned int jresult ;
55670   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55671   Dali::Actor arg2 ;
55672   Dali::HoverEvent *arg3 = 0 ;
55673   Dali::Actor *argp2 ;
55674   bool result;
55675
55676   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55677   argp2 = (Dali::Actor *)jarg2;
55678   if (!argp2) {
55679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55680     return 0;
55681   }
55682   arg2 = *argp2;
55683   arg3 = (Dali::HoverEvent *)jarg3;
55684   if (!arg3) {
55685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55686     return 0;
55687   }
55688   {
55689     try {
55690       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55691     } catch (std::out_of_range& e) {
55692       {
55693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55694       };
55695     } catch (std::exception& e) {
55696       {
55697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55698       };
55699     } catch (Dali::DaliException e) {
55700       {
55701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55702       };
55703     } catch (...) {
55704       {
55705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55706       };
55707     }
55708   }
55709
55710   jresult = result;
55711   return jresult;
55712 }
55713
55714
55715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55716   void * jresult ;
55717   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55718
55719   {
55720     try {
55721       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55722     } catch (std::out_of_range& e) {
55723       {
55724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55725       };
55726     } catch (std::exception& e) {
55727       {
55728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55729       };
55730     } catch (Dali::DaliException e) {
55731       {
55732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55733       };
55734     } catch (...) {
55735       {
55736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55737       };
55738     }
55739   }
55740
55741   jresult = (void *)result;
55742   return jresult;
55743 }
55744
55745
55746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55747   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55748
55749   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55750   {
55751     try {
55752       delete arg1;
55753     } catch (std::out_of_range& e) {
55754       {
55755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55756       };
55757     } catch (std::exception& e) {
55758       {
55759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55760       };
55761     } catch (Dali::DaliException e) {
55762       {
55763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55764       };
55765     } catch (...) {
55766       {
55767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55768       };
55769     }
55770   }
55771
55772 }
55773
55774
55775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55776   unsigned int jresult ;
55777   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55778   bool result;
55779
55780   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55781   {
55782     try {
55783       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);
55784     } catch (std::out_of_range& e) {
55785       {
55786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55787       };
55788     } catch (std::exception& e) {
55789       {
55790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55791       };
55792     } catch (Dali::DaliException e) {
55793       {
55794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55795       };
55796     } catch (...) {
55797       {
55798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55799       };
55800     }
55801   }
55802
55803   jresult = result;
55804   return jresult;
55805 }
55806
55807
55808 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55809   unsigned long jresult ;
55810   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55811   std::size_t result;
55812
55813   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55814   {
55815     try {
55816       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);
55817     } catch (std::out_of_range& e) {
55818       {
55819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55820       };
55821     } catch (std::exception& e) {
55822       {
55823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55824       };
55825     } catch (Dali::DaliException e) {
55826       {
55827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55828       };
55829     } catch (...) {
55830       {
55831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55832       };
55833     }
55834   }
55835
55836   jresult = (unsigned long)result;
55837   return jresult;
55838 }
55839
55840
55841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55842   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55843   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55844
55845   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55846   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55847   {
55848     try {
55849       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55850     } catch (std::out_of_range& e) {
55851       {
55852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55853       };
55854     } catch (std::exception& e) {
55855       {
55856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55857       };
55858     } catch (Dali::DaliException e) {
55859       {
55860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55861       };
55862     } catch (...) {
55863       {
55864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55865       };
55866     }
55867   }
55868
55869 }
55870
55871
55872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55873   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55874   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55875
55876   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55877   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55878   {
55879     try {
55880       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55881     } catch (std::out_of_range& e) {
55882       {
55883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55884       };
55885     } catch (std::exception& e) {
55886       {
55887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55888       };
55889     } catch (Dali::DaliException e) {
55890       {
55891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55892       };
55893     } catch (...) {
55894       {
55895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55896       };
55897     }
55898   }
55899
55900 }
55901
55902
55903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55904   unsigned int jresult ;
55905   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55906   Dali::Actor arg2 ;
55907   Dali::WheelEvent *arg3 = 0 ;
55908   Dali::Actor *argp2 ;
55909   bool result;
55910
55911   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55912   argp2 = (Dali::Actor *)jarg2;
55913   if (!argp2) {
55914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55915     return 0;
55916   }
55917   arg2 = *argp2;
55918   arg3 = (Dali::WheelEvent *)jarg3;
55919   if (!arg3) {
55920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55921     return 0;
55922   }
55923   {
55924     try {
55925       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55926     } catch (std::out_of_range& e) {
55927       {
55928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55929       };
55930     } catch (std::exception& e) {
55931       {
55932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55933       };
55934     } catch (Dali::DaliException e) {
55935       {
55936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55937       };
55938     } catch (...) {
55939       {
55940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55941       };
55942     }
55943   }
55944
55945   jresult = result;
55946   return jresult;
55947 }
55948
55949
55950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55951   void * jresult ;
55952   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55953
55954   {
55955     try {
55956       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55957     } catch (std::out_of_range& e) {
55958       {
55959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55960       };
55961     } catch (std::exception& e) {
55962       {
55963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55964       };
55965     } catch (Dali::DaliException e) {
55966       {
55967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55968       };
55969     } catch (...) {
55970       {
55971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55972       };
55973     }
55974   }
55975
55976   jresult = (void *)result;
55977   return jresult;
55978 }
55979
55980
55981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55982   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55983
55984   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55985   {
55986     try {
55987       delete arg1;
55988     } catch (std::out_of_range& e) {
55989       {
55990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55991       };
55992     } catch (std::exception& e) {
55993       {
55994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55995       };
55996     } catch (Dali::DaliException e) {
55997       {
55998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55999       };
56000     } catch (...) {
56001       {
56002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56003       };
56004     }
56005   }
56006
56007 }
56008
56009
56010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56011   unsigned int jresult ;
56012   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56013   bool result;
56014
56015   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56016   {
56017     try {
56018       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56019     } catch (std::out_of_range& e) {
56020       {
56021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56022       };
56023     } catch (std::exception& e) {
56024       {
56025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56026       };
56027     } catch (Dali::DaliException e) {
56028       {
56029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56030       };
56031     } catch (...) {
56032       {
56033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56034       };
56035     }
56036   }
56037
56038   jresult = result;
56039   return jresult;
56040 }
56041
56042
56043 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56044   unsigned long jresult ;
56045   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56046   std::size_t result;
56047
56048   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56049   {
56050     try {
56051       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56052     } catch (std::out_of_range& e) {
56053       {
56054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56055       };
56056     } catch (std::exception& e) {
56057       {
56058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56059       };
56060     } catch (Dali::DaliException e) {
56061       {
56062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56063       };
56064     } catch (...) {
56065       {
56066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56067       };
56068     }
56069   }
56070
56071   jresult = (unsigned long)result;
56072   return jresult;
56073 }
56074
56075
56076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56077   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56078   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56079
56080   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56081   arg2 = (void (*)(Dali::Actor))jarg2;
56082   {
56083     try {
56084       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56085     } catch (std::out_of_range& e) {
56086       {
56087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56088       };
56089     } catch (std::exception& e) {
56090       {
56091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56092       };
56093     } catch (Dali::DaliException e) {
56094       {
56095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56096       };
56097     } catch (...) {
56098       {
56099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56100       };
56101     }
56102   }
56103
56104 }
56105
56106
56107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56108   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56109   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56110
56111   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56112   arg2 = (void (*)(Dali::Actor))jarg2;
56113   {
56114     try {
56115       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56116     } catch (std::out_of_range& e) {
56117       {
56118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56119       };
56120     } catch (std::exception& e) {
56121       {
56122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56123       };
56124     } catch (Dali::DaliException e) {
56125       {
56126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56127       };
56128     } catch (...) {
56129       {
56130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56131       };
56132     }
56133   }
56134
56135 }
56136
56137
56138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56139   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56140   Dali::Actor arg2 ;
56141   Dali::Actor *argp2 ;
56142
56143   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56144   argp2 = (Dali::Actor *)jarg2;
56145   if (!argp2) {
56146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56147     return ;
56148   }
56149   arg2 = *argp2;
56150   {
56151     try {
56152       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56153     } catch (std::out_of_range& e) {
56154       {
56155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56156       };
56157     } catch (std::exception& e) {
56158       {
56159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56160       };
56161     } catch (Dali::DaliException e) {
56162       {
56163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56164       };
56165     } catch (...) {
56166       {
56167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56168       };
56169     }
56170   }
56171
56172 }
56173
56174
56175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56176   void * jresult ;
56177   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56178
56179   {
56180     try {
56181       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56182     } catch (std::out_of_range& e) {
56183       {
56184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56185       };
56186     } catch (std::exception& e) {
56187       {
56188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56189       };
56190     } catch (Dali::DaliException e) {
56191       {
56192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56193       };
56194     } catch (...) {
56195       {
56196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56197       };
56198     }
56199   }
56200
56201   jresult = (void *)result;
56202   return jresult;
56203 }
56204
56205
56206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56207   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56208
56209   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56210   {
56211     try {
56212       delete arg1;
56213     } catch (std::out_of_range& e) {
56214       {
56215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56216       };
56217     } catch (std::exception& e) {
56218       {
56219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56220       };
56221     } catch (Dali::DaliException e) {
56222       {
56223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56224       };
56225     } catch (...) {
56226       {
56227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56228       };
56229     }
56230   }
56231
56232 }
56233
56234
56235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56236   unsigned int jresult ;
56237   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56238   bool result;
56239
56240   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56241   {
56242     try {
56243       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56244     } catch (std::out_of_range& e) {
56245       {
56246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56247       };
56248     } catch (std::exception& e) {
56249       {
56250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56251       };
56252     } catch (Dali::DaliException e) {
56253       {
56254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56255       };
56256     } catch (...) {
56257       {
56258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56259       };
56260     }
56261   }
56262
56263   jresult = result;
56264   return jresult;
56265 }
56266
56267
56268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56269   unsigned long jresult ;
56270   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56271   std::size_t result;
56272
56273   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56274   {
56275     try {
56276       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56277     } catch (std::out_of_range& e) {
56278       {
56279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56280       };
56281     } catch (std::exception& e) {
56282       {
56283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56284       };
56285     } catch (Dali::DaliException e) {
56286       {
56287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56288       };
56289     } catch (...) {
56290       {
56291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56292       };
56293     }
56294   }
56295
56296   jresult = (unsigned long)result;
56297   return jresult;
56298 }
56299
56300
56301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56302   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56303   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56304
56305   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56306   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56307   {
56308     try {
56309       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56310     } catch (std::out_of_range& e) {
56311       {
56312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56313       };
56314     } catch (std::exception& e) {
56315       {
56316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56317       };
56318     } catch (Dali::DaliException e) {
56319       {
56320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56321       };
56322     } catch (...) {
56323       {
56324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56325       };
56326     }
56327   }
56328
56329 }
56330
56331
56332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56333   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56334   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56335
56336   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56337   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56338   {
56339     try {
56340       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56341     } catch (std::out_of_range& e) {
56342       {
56343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56344       };
56345     } catch (std::exception& e) {
56346       {
56347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56348       };
56349     } catch (Dali::DaliException e) {
56350       {
56351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56352       };
56353     } catch (...) {
56354       {
56355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56356       };
56357     }
56358   }
56359
56360 }
56361
56362
56363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56364   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56365   Dali::KeyEvent *arg2 = 0 ;
56366
56367   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56368   arg2 = (Dali::KeyEvent *)jarg2;
56369   if (!arg2) {
56370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56371     return ;
56372   }
56373   {
56374     try {
56375       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56376     } catch (std::out_of_range& e) {
56377       {
56378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56379       };
56380     } catch (std::exception& e) {
56381       {
56382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56383       };
56384     } catch (Dali::DaliException e) {
56385       {
56386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56387       };
56388     } catch (...) {
56389       {
56390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56391       };
56392     }
56393   }
56394
56395 }
56396
56397
56398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56399   void * jresult ;
56400   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56401
56402   {
56403     try {
56404       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56405     } catch (std::out_of_range& e) {
56406       {
56407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56408       };
56409     } catch (std::exception& e) {
56410       {
56411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56412       };
56413     } catch (Dali::DaliException e) {
56414       {
56415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56416       };
56417     } catch (...) {
56418       {
56419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56420       };
56421     }
56422   }
56423
56424   jresult = (void *)result;
56425   return jresult;
56426 }
56427
56428
56429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56430   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56431
56432   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56433   {
56434     try {
56435       delete arg1;
56436     } catch (std::out_of_range& e) {
56437       {
56438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56439       };
56440     } catch (std::exception& e) {
56441       {
56442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56443       };
56444     } catch (Dali::DaliException e) {
56445       {
56446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56447       };
56448     } catch (...) {
56449       {
56450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56451       };
56452     }
56453   }
56454
56455 }
56456
56457
56458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56459   unsigned int jresult ;
56460   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56461   bool result;
56462
56463   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56464   {
56465     try {
56466       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56467     } catch (std::out_of_range& e) {
56468       {
56469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56470       };
56471     } catch (std::exception& e) {
56472       {
56473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56474       };
56475     } catch (Dali::DaliException e) {
56476       {
56477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56478       };
56479     } catch (...) {
56480       {
56481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56482       };
56483     }
56484   }
56485
56486   jresult = result;
56487   return jresult;
56488 }
56489
56490
56491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56492   unsigned long jresult ;
56493   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56494   std::size_t result;
56495
56496   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56497   {
56498     try {
56499       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56500     } catch (std::out_of_range& e) {
56501       {
56502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56503       };
56504     } catch (std::exception& e) {
56505       {
56506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56507       };
56508     } catch (Dali::DaliException e) {
56509       {
56510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56511       };
56512     } catch (...) {
56513       {
56514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56515       };
56516     }
56517   }
56518
56519   jresult = (unsigned long)result;
56520   return jresult;
56521 }
56522
56523
56524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56525   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56526   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56527
56528   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56529   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56530   {
56531     try {
56532       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56533     } catch (std::out_of_range& e) {
56534       {
56535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56536       };
56537     } catch (std::exception& e) {
56538       {
56539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56540       };
56541     } catch (Dali::DaliException e) {
56542       {
56543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56544       };
56545     } catch (...) {
56546       {
56547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56548       };
56549     }
56550   }
56551
56552 }
56553
56554
56555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56556   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56557   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56558
56559   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56560   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56561   {
56562     try {
56563       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56564     } catch (std::out_of_range& e) {
56565       {
56566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56567       };
56568     } catch (std::exception& e) {
56569       {
56570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56571       };
56572     } catch (Dali::DaliException e) {
56573       {
56574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56575       };
56576     } catch (...) {
56577       {
56578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56579       };
56580     }
56581   }
56582
56583 }
56584
56585
56586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56587   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56588   Dali::TouchData *arg2 = 0 ;
56589
56590   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56591   arg2 = (Dali::TouchData *)jarg2;
56592   if (!arg2) {
56593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56594     return ;
56595   }
56596   {
56597     try {
56598       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56599     } catch (std::out_of_range& e) {
56600       {
56601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56602       };
56603     } catch (std::exception& e) {
56604       {
56605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56606       };
56607     } catch (Dali::DaliException e) {
56608       {
56609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56610       };
56611     } catch (...) {
56612       {
56613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56614       };
56615     }
56616   }
56617
56618 }
56619
56620
56621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56622   void * jresult ;
56623   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56624
56625   {
56626     try {
56627       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56628     } catch (std::out_of_range& e) {
56629       {
56630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56631       };
56632     } catch (std::exception& e) {
56633       {
56634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56635       };
56636     } catch (Dali::DaliException e) {
56637       {
56638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56639       };
56640     } catch (...) {
56641       {
56642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56643       };
56644     }
56645   }
56646
56647   jresult = (void *)result;
56648   return jresult;
56649 }
56650
56651
56652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56653   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56654
56655   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56656   {
56657     try {
56658       delete arg1;
56659     } catch (std::out_of_range& e) {
56660       {
56661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56662       };
56663     } catch (std::exception& e) {
56664       {
56665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56666       };
56667     } catch (Dali::DaliException e) {
56668       {
56669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56670       };
56671     } catch (...) {
56672       {
56673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56674       };
56675     }
56676   }
56677
56678 }
56679
56680
56681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56682   unsigned int jresult ;
56683   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56684   bool result;
56685
56686   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56687   {
56688     try {
56689       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56690     } catch (std::out_of_range& e) {
56691       {
56692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56693       };
56694     } catch (std::exception& e) {
56695       {
56696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56697       };
56698     } catch (Dali::DaliException e) {
56699       {
56700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56701       };
56702     } catch (...) {
56703       {
56704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56705       };
56706     }
56707   }
56708
56709   jresult = result;
56710   return jresult;
56711 }
56712
56713
56714 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56715   unsigned long jresult ;
56716   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56717   std::size_t result;
56718
56719   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56720   {
56721     try {
56722       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56723     } catch (std::out_of_range& e) {
56724       {
56725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56726       };
56727     } catch (std::exception& e) {
56728       {
56729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56730       };
56731     } catch (Dali::DaliException e) {
56732       {
56733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56734       };
56735     } catch (...) {
56736       {
56737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56738       };
56739     }
56740   }
56741
56742   jresult = (unsigned long)result;
56743   return jresult;
56744 }
56745
56746
56747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56748   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56749   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56750
56751   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56752   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56753   {
56754     try {
56755       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56756     } catch (std::out_of_range& e) {
56757       {
56758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56759       };
56760     } catch (std::exception& e) {
56761       {
56762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56763       };
56764     } catch (Dali::DaliException e) {
56765       {
56766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56767       };
56768     } catch (...) {
56769       {
56770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56771       };
56772     }
56773   }
56774
56775 }
56776
56777
56778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56779   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56780   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56781
56782   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56783   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56784   {
56785     try {
56786       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56787     } catch (std::out_of_range& e) {
56788       {
56789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56790       };
56791     } catch (std::exception& e) {
56792       {
56793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56794       };
56795     } catch (Dali::DaliException e) {
56796       {
56797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56798       };
56799     } catch (...) {
56800       {
56801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56802       };
56803     }
56804   }
56805
56806 }
56807
56808
56809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56810   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56811   Dali::WheelEvent *arg2 = 0 ;
56812
56813   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56814   arg2 = (Dali::WheelEvent *)jarg2;
56815   if (!arg2) {
56816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56817     return ;
56818   }
56819   {
56820     try {
56821       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56822     } catch (std::out_of_range& e) {
56823       {
56824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56825       };
56826     } catch (std::exception& e) {
56827       {
56828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56829       };
56830     } catch (Dali::DaliException e) {
56831       {
56832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56833       };
56834     } catch (...) {
56835       {
56836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56837       };
56838     }
56839   }
56840
56841 }
56842
56843
56844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56845   void * jresult ;
56846   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56847
56848   {
56849     try {
56850       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56851     } catch (std::out_of_range& e) {
56852       {
56853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56854       };
56855     } catch (std::exception& e) {
56856       {
56857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56858       };
56859     } catch (Dali::DaliException e) {
56860       {
56861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56862       };
56863     } catch (...) {
56864       {
56865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56866       };
56867     }
56868   }
56869
56870   jresult = (void *)result;
56871   return jresult;
56872 }
56873
56874
56875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56876   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56877
56878   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56879   {
56880     try {
56881       delete arg1;
56882     } catch (std::out_of_range& e) {
56883       {
56884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56885       };
56886     } catch (std::exception& e) {
56887       {
56888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56889       };
56890     } catch (Dali::DaliException e) {
56891       {
56892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56893       };
56894     } catch (...) {
56895       {
56896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56897       };
56898     }
56899   }
56900
56901 }
56902
56903
56904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56905   void * jresult ;
56906   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56907
56908   {
56909     try {
56910       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56911     } catch (std::out_of_range& e) {
56912       {
56913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56914       };
56915     } catch (std::exception& e) {
56916       {
56917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56918       };
56919     } catch (Dali::DaliException e) {
56920       {
56921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56922       };
56923     } catch (...) {
56924       {
56925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56926       };
56927     }
56928   }
56929
56930   jresult = (void *)result;
56931   return jresult;
56932 }
56933
56934
56935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56936   void * jresult ;
56937   Dali::Radian arg1 ;
56938   Dali::Radian arg2 ;
56939   Dali::Radian *argp1 ;
56940   Dali::Radian *argp2 ;
56941   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56942
56943   argp1 = (Dali::Radian *)jarg1;
56944   if (!argp1) {
56945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56946     return 0;
56947   }
56948   arg1 = *argp1;
56949   argp2 = (Dali::Radian *)jarg2;
56950   if (!argp2) {
56951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56952     return 0;
56953   }
56954   arg2 = *argp2;
56955   {
56956     try {
56957       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56958     } catch (std::out_of_range& e) {
56959       {
56960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56961       };
56962     } catch (std::exception& e) {
56963       {
56964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56965       };
56966     } catch (Dali::DaliException e) {
56967       {
56968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56969       };
56970     } catch (...) {
56971       {
56972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56973       };
56974     }
56975   }
56976
56977   jresult = (void *)result;
56978   return jresult;
56979 }
56980
56981
56982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56983   void * jresult ;
56984   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56985   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56986
56987   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56988   if (!arg1) {
56989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56990     return 0;
56991   }
56992   {
56993     try {
56994       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56995     } catch (std::out_of_range& e) {
56996       {
56997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56998       };
56999     } catch (std::exception& e) {
57000       {
57001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57002       };
57003     } catch (Dali::DaliException e) {
57004       {
57005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57006       };
57007     } catch (...) {
57008       {
57009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57010       };
57011     }
57012   }
57013
57014   jresult = (void *)result;
57015   return jresult;
57016 }
57017
57018
57019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57020   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57021   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57022
57023   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57024   arg2 = (Dali::Radian *)jarg2;
57025   if (arg1) (arg1)->first = *arg2;
57026 }
57027
57028
57029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57030   void * jresult ;
57031   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57032   Dali::Radian *result = 0 ;
57033
57034   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57035   result = (Dali::Radian *)& ((arg1)->first);
57036   jresult = (void *)result;
57037   return jresult;
57038 }
57039
57040
57041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57042   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57043   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57044
57045   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57046   arg2 = (Dali::Radian *)jarg2;
57047   if (arg1) (arg1)->second = *arg2;
57048 }
57049
57050
57051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57052   void * jresult ;
57053   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57054   Dali::Radian *result = 0 ;
57055
57056   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57057   result = (Dali::Radian *)& ((arg1)->second);
57058   jresult = (void *)result;
57059   return jresult;
57060 }
57061
57062
57063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57064   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57065
57066   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57067   {
57068     try {
57069       delete arg1;
57070     } catch (std::out_of_range& e) {
57071       {
57072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57073       };
57074     } catch (std::exception& e) {
57075       {
57076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57077       };
57078     } catch (Dali::DaliException e) {
57079       {
57080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57081       };
57082     } catch (...) {
57083       {
57084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57085       };
57086     }
57087   }
57088
57089 }
57090
57091
57092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57093   unsigned int jresult ;
57094   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57095   bool result;
57096
57097   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57098   {
57099     try {
57100       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);
57101     } catch (std::out_of_range& e) {
57102       {
57103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57104       };
57105     } catch (std::exception& e) {
57106       {
57107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57108       };
57109     } catch (Dali::DaliException e) {
57110       {
57111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57112       };
57113     } catch (...) {
57114       {
57115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57116       };
57117     }
57118   }
57119
57120   jresult = result;
57121   return jresult;
57122 }
57123
57124
57125 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57126   unsigned long jresult ;
57127   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57128   std::size_t result;
57129
57130   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57131   {
57132     try {
57133       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);
57134     } catch (std::out_of_range& e) {
57135       {
57136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57137       };
57138     } catch (std::exception& e) {
57139       {
57140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57141       };
57142     } catch (Dali::DaliException e) {
57143       {
57144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57145       };
57146     } catch (...) {
57147       {
57148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57149       };
57150     }
57151   }
57152
57153   jresult = (unsigned long)result;
57154   return jresult;
57155 }
57156
57157
57158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57159   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57160   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57161
57162   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57163   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57164   {
57165     try {
57166       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57167     } catch (std::out_of_range& e) {
57168       {
57169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57170       };
57171     } catch (std::exception& e) {
57172       {
57173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57174       };
57175     } catch (Dali::DaliException e) {
57176       {
57177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57178       };
57179     } catch (...) {
57180       {
57181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57182       };
57183     }
57184   }
57185
57186 }
57187
57188
57189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57190   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57191   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57192
57193   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57194   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57195   {
57196     try {
57197       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57198     } catch (std::out_of_range& e) {
57199       {
57200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57201       };
57202     } catch (std::exception& e) {
57203       {
57204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57205       };
57206     } catch (Dali::DaliException e) {
57207       {
57208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57209       };
57210     } catch (...) {
57211       {
57212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57213       };
57214     }
57215   }
57216
57217 }
57218
57219
57220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57221   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57222   Dali::Actor arg2 ;
57223   Dali::PanGesture *arg3 = 0 ;
57224   Dali::Actor *argp2 ;
57225
57226   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57227   argp2 = (Dali::Actor *)jarg2;
57228   if (!argp2) {
57229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57230     return ;
57231   }
57232   arg2 = *argp2;
57233   arg3 = (Dali::PanGesture *)jarg3;
57234   if (!arg3) {
57235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57236     return ;
57237   }
57238   {
57239     try {
57240       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57241     } catch (std::out_of_range& e) {
57242       {
57243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57244       };
57245     } catch (std::exception& e) {
57246       {
57247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57248       };
57249     } catch (Dali::DaliException e) {
57250       {
57251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57252       };
57253     } catch (...) {
57254       {
57255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57256       };
57257     }
57258   }
57259
57260 }
57261
57262
57263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57264   void * jresult ;
57265   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57266
57267   {
57268     try {
57269       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57270     } catch (std::out_of_range& e) {
57271       {
57272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57273       };
57274     } catch (std::exception& e) {
57275       {
57276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57277       };
57278     } catch (Dali::DaliException e) {
57279       {
57280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57281       };
57282     } catch (...) {
57283       {
57284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57285       };
57286     }
57287   }
57288
57289   jresult = (void *)result;
57290   return jresult;
57291 }
57292
57293
57294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57295   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57296
57297   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57298   {
57299     try {
57300       delete arg1;
57301     } catch (std::out_of_range& e) {
57302       {
57303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57304       };
57305     } catch (std::exception& e) {
57306       {
57307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57308       };
57309     } catch (Dali::DaliException e) {
57310       {
57311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57312       };
57313     } catch (...) {
57314       {
57315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57316       };
57317     }
57318   }
57319
57320 }
57321
57322
57323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57324   unsigned int jresult ;
57325   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57326   bool result;
57327
57328   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57329   {
57330     try {
57331       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);
57332     } catch (std::out_of_range& e) {
57333       {
57334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57335       };
57336     } catch (std::exception& e) {
57337       {
57338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57339       };
57340     } catch (Dali::DaliException e) {
57341       {
57342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57343       };
57344     } catch (...) {
57345       {
57346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57347       };
57348     }
57349   }
57350
57351   jresult = result;
57352   return jresult;
57353 }
57354
57355
57356 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57357   unsigned long jresult ;
57358   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57359   std::size_t result;
57360
57361   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57362   {
57363     try {
57364       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);
57365     } catch (std::out_of_range& e) {
57366       {
57367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57368       };
57369     } catch (std::exception& e) {
57370       {
57371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57372       };
57373     } catch (Dali::DaliException e) {
57374       {
57375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57376       };
57377     } catch (...) {
57378       {
57379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57380       };
57381     }
57382   }
57383
57384   jresult = (unsigned long)result;
57385   return jresult;
57386 }
57387
57388
57389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57390   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57391   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57392
57393   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57394   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57395   {
57396     try {
57397       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57398     } catch (std::out_of_range& e) {
57399       {
57400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57401       };
57402     } catch (std::exception& e) {
57403       {
57404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57405       };
57406     } catch (Dali::DaliException e) {
57407       {
57408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57409       };
57410     } catch (...) {
57411       {
57412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57413       };
57414     }
57415   }
57416
57417 }
57418
57419
57420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57421   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57422   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57423
57424   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57425   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57426   {
57427     try {
57428       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57429     } catch (std::out_of_range& e) {
57430       {
57431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57432       };
57433     } catch (std::exception& e) {
57434       {
57435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57436       };
57437     } catch (Dali::DaliException e) {
57438       {
57439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57440       };
57441     } catch (...) {
57442       {
57443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57444       };
57445     }
57446   }
57447
57448 }
57449
57450
57451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57452   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57453   Dali::Actor arg2 ;
57454   Dali::PinchGesture *arg3 = 0 ;
57455   Dali::Actor *argp2 ;
57456
57457   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57458   argp2 = (Dali::Actor *)jarg2;
57459   if (!argp2) {
57460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57461     return ;
57462   }
57463   arg2 = *argp2;
57464   arg3 = (Dali::PinchGesture *)jarg3;
57465   if (!arg3) {
57466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57467     return ;
57468   }
57469   {
57470     try {
57471       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57472     } catch (std::out_of_range& e) {
57473       {
57474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57475       };
57476     } catch (std::exception& e) {
57477       {
57478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57479       };
57480     } catch (Dali::DaliException e) {
57481       {
57482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57483       };
57484     } catch (...) {
57485       {
57486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57487       };
57488     }
57489   }
57490
57491 }
57492
57493
57494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57495   void * jresult ;
57496   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57497
57498   {
57499     try {
57500       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57501     } catch (std::out_of_range& e) {
57502       {
57503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57504       };
57505     } catch (std::exception& e) {
57506       {
57507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57508       };
57509     } catch (Dali::DaliException e) {
57510       {
57511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57512       };
57513     } catch (...) {
57514       {
57515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57516       };
57517     }
57518   }
57519
57520   jresult = (void *)result;
57521   return jresult;
57522 }
57523
57524
57525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57526   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57527
57528   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57529   {
57530     try {
57531       delete arg1;
57532     } catch (std::out_of_range& e) {
57533       {
57534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57535       };
57536     } catch (std::exception& e) {
57537       {
57538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57539       };
57540     } catch (Dali::DaliException e) {
57541       {
57542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57543       };
57544     } catch (...) {
57545       {
57546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57547       };
57548     }
57549   }
57550
57551 }
57552
57553
57554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57555   unsigned int jresult ;
57556   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57557   bool result;
57558
57559   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57560   {
57561     try {
57562       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);
57563     } catch (std::out_of_range& e) {
57564       {
57565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57566       };
57567     } catch (std::exception& e) {
57568       {
57569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57570       };
57571     } catch (Dali::DaliException e) {
57572       {
57573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57574       };
57575     } catch (...) {
57576       {
57577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57578       };
57579     }
57580   }
57581
57582   jresult = result;
57583   return jresult;
57584 }
57585
57586
57587 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57588   unsigned long jresult ;
57589   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57590   std::size_t result;
57591
57592   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57593   {
57594     try {
57595       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);
57596     } catch (std::out_of_range& e) {
57597       {
57598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57599       };
57600     } catch (std::exception& e) {
57601       {
57602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57603       };
57604     } catch (Dali::DaliException e) {
57605       {
57606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57607       };
57608     } catch (...) {
57609       {
57610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57611       };
57612     }
57613   }
57614
57615   jresult = (unsigned long)result;
57616   return jresult;
57617 }
57618
57619
57620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57621   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57622   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57623
57624   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57625   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57626   {
57627     try {
57628       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57629     } catch (std::out_of_range& e) {
57630       {
57631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57632       };
57633     } catch (std::exception& e) {
57634       {
57635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57636       };
57637     } catch (Dali::DaliException e) {
57638       {
57639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57640       };
57641     } catch (...) {
57642       {
57643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57644       };
57645     }
57646   }
57647
57648 }
57649
57650
57651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57652   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57653   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57654
57655   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57656   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57657   {
57658     try {
57659       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57660     } catch (std::out_of_range& e) {
57661       {
57662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57663       };
57664     } catch (std::exception& e) {
57665       {
57666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57667       };
57668     } catch (Dali::DaliException e) {
57669       {
57670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57671       };
57672     } catch (...) {
57673       {
57674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57675       };
57676     }
57677   }
57678
57679 }
57680
57681
57682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57683   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57684   Dali::Actor arg2 ;
57685   Dali::TapGesture *arg3 = 0 ;
57686   Dali::Actor *argp2 ;
57687
57688   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57689   argp2 = (Dali::Actor *)jarg2;
57690   if (!argp2) {
57691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57692     return ;
57693   }
57694   arg2 = *argp2;
57695   arg3 = (Dali::TapGesture *)jarg3;
57696   if (!arg3) {
57697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57698     return ;
57699   }
57700   {
57701     try {
57702       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57703     } catch (std::out_of_range& e) {
57704       {
57705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57706       };
57707     } catch (std::exception& e) {
57708       {
57709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57710       };
57711     } catch (Dali::DaliException e) {
57712       {
57713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57714       };
57715     } catch (...) {
57716       {
57717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57718       };
57719     }
57720   }
57721
57722 }
57723
57724
57725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57726   void * jresult ;
57727   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57728
57729   {
57730     try {
57731       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57732     } catch (std::out_of_range& e) {
57733       {
57734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57735       };
57736     } catch (std::exception& e) {
57737       {
57738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57739       };
57740     } catch (Dali::DaliException e) {
57741       {
57742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57743       };
57744     } catch (...) {
57745       {
57746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57747       };
57748     }
57749   }
57750
57751   jresult = (void *)result;
57752   return jresult;
57753 }
57754
57755
57756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57757   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57758
57759   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57760   {
57761     try {
57762       delete arg1;
57763     } catch (std::out_of_range& e) {
57764       {
57765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57766       };
57767     } catch (std::exception& e) {
57768       {
57769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57770       };
57771     } catch (Dali::DaliException e) {
57772       {
57773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57774       };
57775     } catch (...) {
57776       {
57777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57778       };
57779     }
57780   }
57781
57782 }
57783
57784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57785   unsigned int jresult ;
57786   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57787   bool result;
57788
57789   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57790   {
57791     try {
57792       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57793     } catch (std::out_of_range& e) {
57794       {
57795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57796       };
57797     } catch (std::exception& e) {
57798       {
57799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57800       };
57801     } catch (Dali::DaliException e) {
57802       {
57803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57804       };
57805     } catch (...) {
57806       {
57807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57808       };
57809     }
57810   }
57811
57812   jresult = result;
57813   return jresult;
57814 }
57815
57816
57817 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57818   unsigned long jresult ;
57819   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57820   std::size_t result;
57821
57822   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57823   {
57824     try {
57825       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57826     } catch (std::out_of_range& e) {
57827       {
57828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57829       };
57830     } catch (std::exception& e) {
57831       {
57832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57833       };
57834     } catch (Dali::DaliException e) {
57835       {
57836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57837       };
57838     } catch (...) {
57839       {
57840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57841       };
57842     }
57843   }
57844
57845   jresult = (unsigned long)result;
57846   return jresult;
57847 }
57848
57849
57850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57851   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57852   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57853
57854   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57855   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57856   {
57857     try {
57858       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57859     } catch (std::out_of_range& e) {
57860       {
57861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57862       };
57863     } catch (std::exception& e) {
57864       {
57865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57866       };
57867     } catch (Dali::DaliException e) {
57868       {
57869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57870       };
57871     } catch (...) {
57872       {
57873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57874       };
57875     }
57876   }
57877
57878 }
57879
57880
57881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57882   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57883   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57884
57885   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57886   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57887   {
57888     try {
57889       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57890     } catch (std::out_of_range& e) {
57891       {
57892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57893       };
57894     } catch (std::exception& e) {
57895       {
57896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57897       };
57898     } catch (Dali::DaliException e) {
57899       {
57900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57901       };
57902     } catch (...) {
57903       {
57904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57905       };
57906     }
57907   }
57908
57909 }
57910
57911
57912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57913   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57914   Dali::ResourceImage arg2 ;
57915   Dali::ResourceImage *argp2 ;
57916
57917   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57918   argp2 = (Dali::ResourceImage *)jarg2;
57919   if (!argp2) {
57920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57921     return ;
57922   }
57923   arg2 = *argp2;
57924   {
57925     try {
57926       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57927     } catch (std::out_of_range& e) {
57928       {
57929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57930       };
57931     } catch (std::exception& e) {
57932       {
57933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57934       };
57935     } catch (Dali::DaliException e) {
57936       {
57937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57938       };
57939     } catch (...) {
57940       {
57941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57942       };
57943     }
57944   }
57945
57946 }
57947
57948
57949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57950   void * jresult ;
57951   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57952
57953   {
57954     try {
57955       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57956     } catch (std::out_of_range& e) {
57957       {
57958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57959       };
57960     } catch (std::exception& e) {
57961       {
57962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57963       };
57964     } catch (Dali::DaliException e) {
57965       {
57966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57967       };
57968     } catch (...) {
57969       {
57970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57971       };
57972     }
57973   }
57974
57975   jresult = (void *)result;
57976   return jresult;
57977 }
57978
57979
57980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57981   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57982
57983   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57984   {
57985     try {
57986       delete arg1;
57987     } catch (std::out_of_range& e) {
57988       {
57989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57990       };
57991     } catch (std::exception& e) {
57992       {
57993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57994       };
57995     } catch (Dali::DaliException e) {
57996       {
57997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57998       };
57999     } catch (...) {
58000       {
58001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58002       };
58003     }
58004   }
58005
58006 }
58007
58008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58009   unsigned int jresult ;
58010   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58011   bool result = false;
58012
58013   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58014   {
58015     try {
58016       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
58017     } catch (std::out_of_range& e) {
58018       {
58019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58020       };
58021     } catch (std::exception& e) {
58022       {
58023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58024       };
58025     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58026   }
58027   jresult = result;
58028   return jresult;
58029 }
58030
58031 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58032   unsigned long jresult ;
58033   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58034   std::size_t result = 0;
58035
58036   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58037   {
58038     try {
58039       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
58040     } catch (std::out_of_range& e) {
58041       {
58042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58043       };
58044     } catch (std::exception& e) {
58045       {
58046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58047       };
58048     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58049   }
58050   jresult = (unsigned long)result;
58051   return jresult;
58052 }
58053
58054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58055   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58056   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58057
58058   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58059   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58060   {
58061     try {
58062       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58063     } catch (std::out_of_range& e) {
58064       {
58065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58066       };
58067     } catch (std::exception& e) {
58068       {
58069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58070       };
58071     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58072   }
58073 }
58074
58075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58076   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58077   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58078
58079   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58080   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58081   {
58082     try {
58083       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58084     } catch (std::out_of_range& e) {
58085       {
58086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58087       };
58088     } catch (std::exception& e) {
58089       {
58090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58091       };
58092     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58093   }
58094 }
58095
58096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58097   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58098   Dali::Actor arg2 ;
58099   //bool arg3 ;
58100   Dali::LayoutDirection::Type arg4 ;
58101   Dali::Actor *argp2 ;
58102
58103   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58104   argp2 = (Dali::Actor *)jarg2;
58105   if (!argp2) {
58106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58107     return ;
58108   }
58109   arg2 = *argp2;
58110   //arg3 = jarg3 ? true : false;
58111   arg4 = (Dali::LayoutDirection::Type)jarg4;
58112   {
58113     try {
58114       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58115     } catch (std::out_of_range& e) {
58116       {
58117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58118       };
58119     } catch (std::exception& e) {
58120       {
58121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58122       };
58123     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58124   }
58125 }
58126
58127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58128   void * jresult ;
58129   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58130
58131   {
58132     try {
58133       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58134     } catch (std::out_of_range& e) {
58135       {
58136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58137       };
58138     } catch (std::exception& e) {
58139       {
58140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58141       };
58142     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58143   }
58144   jresult = (void *)result;
58145   return jresult;
58146 }
58147
58148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58149   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58150
58151   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58152   {
58153     try {
58154       delete arg1;
58155     } catch (std::out_of_range& e) {
58156       {
58157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58158       };
58159     } catch (std::exception& e) {
58160       {
58161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58162       };
58163     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58164   }
58165 }
58166
58167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58168   unsigned int jresult ;
58169   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58170   bool result;
58171
58172   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58173   {
58174     try {
58175       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);
58176     } catch (std::out_of_range& e) {
58177       {
58178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58179       };
58180     } catch (std::exception& e) {
58181       {
58182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58183       };
58184     } catch (Dali::DaliException e) {
58185       {
58186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58187       };
58188     } catch (...) {
58189       {
58190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58191       };
58192     }
58193   }
58194
58195   jresult = result;
58196   return jresult;
58197 }
58198
58199
58200 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58201   unsigned long jresult ;
58202   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58203   std::size_t result;
58204
58205   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58206   {
58207     try {
58208       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);
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 (Dali::DaliException e) {
58218       {
58219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58220       };
58221     } catch (...) {
58222       {
58223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58224       };
58225     }
58226   }
58227
58228   jresult = (unsigned long)result;
58229   return jresult;
58230 }
58231
58232
58233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58234   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58235   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58236
58237   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58238   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58239   {
58240     try {
58241       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58242     } catch (std::out_of_range& e) {
58243       {
58244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58245       };
58246     } catch (std::exception& e) {
58247       {
58248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58249       };
58250     } catch (Dali::DaliException e) {
58251       {
58252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58253       };
58254     } catch (...) {
58255       {
58256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58257       };
58258     }
58259   }
58260
58261 }
58262
58263
58264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58265   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58266   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58267
58268   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58269   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58270   {
58271     try {
58272       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58273     } catch (std::out_of_range& e) {
58274       {
58275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58276       };
58277     } catch (std::exception& e) {
58278       {
58279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58280       };
58281     } catch (Dali::DaliException e) {
58282       {
58283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58284       };
58285     } catch (...) {
58286       {
58287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58288       };
58289     }
58290   }
58291
58292 }
58293
58294
58295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58296   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58297   Dali::Actor arg2 ;
58298   bool arg3 ;
58299   Dali::DevelActor::VisibilityChange::Type arg4 ;
58300   Dali::Actor *argp2 ;
58301
58302   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58303   argp2 = (Dali::Actor *)jarg2;
58304   if (!argp2) {
58305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58306     return ;
58307   }
58308   arg2 = *argp2;
58309   arg3 = jarg3 ? true : false;
58310   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58311   {
58312     try {
58313       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58314     } catch (std::out_of_range& e) {
58315       {
58316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58317       };
58318     } catch (std::exception& e) {
58319       {
58320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58321       };
58322     } catch (Dali::DaliException e) {
58323       {
58324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58325       };
58326     } catch (...) {
58327       {
58328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58329       };
58330     }
58331   }
58332
58333 }
58334
58335
58336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58337   void * jresult ;
58338   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58339
58340   {
58341     try {
58342       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58343     } catch (std::out_of_range& e) {
58344       {
58345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58346       };
58347     } catch (std::exception& e) {
58348       {
58349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58350       };
58351     } catch (Dali::DaliException e) {
58352       {
58353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58354       };
58355     } catch (...) {
58356       {
58357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58358       };
58359     }
58360   }
58361
58362   jresult = (void *)result;
58363   return jresult;
58364 }
58365
58366
58367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58368   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58369
58370   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58371   {
58372     try {
58373       delete arg1;
58374     } catch (std::out_of_range& e) {
58375       {
58376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58377       };
58378     } catch (std::exception& e) {
58379       {
58380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58381       };
58382     } catch (Dali::DaliException e) {
58383       {
58384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58385       };
58386     } catch (...) {
58387       {
58388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58389       };
58390     }
58391   }
58392
58393 }
58394
58395
58396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58397   void * jresult ;
58398   Dali::Timer *result = 0 ;
58399
58400   {
58401     try {
58402       result = (Dali::Timer *)new Dali::Timer();
58403     } catch (std::out_of_range& e) {
58404       {
58405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58406       };
58407     } catch (std::exception& e) {
58408       {
58409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58410       };
58411     } catch (Dali::DaliException e) {
58412       {
58413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58414       };
58415     } catch (...) {
58416       {
58417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58418       };
58419     }
58420   }
58421
58422   jresult = (void *)result;
58423   return jresult;
58424 }
58425
58426
58427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58428   void * jresult ;
58429   unsigned int arg1 ;
58430   Dali::Timer result;
58431
58432   arg1 = (unsigned int)jarg1;
58433   {
58434     try {
58435       result = Dali::Timer::New(arg1);
58436     } catch (std::out_of_range& e) {
58437       {
58438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58439       };
58440     } catch (std::exception& e) {
58441       {
58442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58443       };
58444     } catch (Dali::DaliException e) {
58445       {
58446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58447       };
58448     } catch (...) {
58449       {
58450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58451       };
58452     }
58453   }
58454
58455   jresult = new Dali::Timer((const Dali::Timer &)result);
58456   return jresult;
58457 }
58458
58459
58460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58461   void * jresult ;
58462   Dali::Timer *arg1 = 0 ;
58463   Dali::Timer *result = 0 ;
58464
58465   arg1 = (Dali::Timer *)jarg1;
58466   if (!arg1) {
58467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58468     return 0;
58469   }
58470   {
58471     try {
58472       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58473     } catch (std::out_of_range& e) {
58474       {
58475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58476       };
58477     } catch (std::exception& e) {
58478       {
58479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58480       };
58481     } catch (Dali::DaliException e) {
58482       {
58483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58484       };
58485     } catch (...) {
58486       {
58487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58488       };
58489     }
58490   }
58491
58492   jresult = (void *)result;
58493   return jresult;
58494 }
58495
58496
58497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58498   void * jresult ;
58499   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58500   Dali::Timer *arg2 = 0 ;
58501   Dali::Timer *result = 0 ;
58502
58503   arg1 = (Dali::Timer *)jarg1;
58504   arg2 = (Dali::Timer *)jarg2;
58505   if (!arg2) {
58506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58507     return 0;
58508   }
58509   {
58510     try {
58511       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58512     } catch (std::out_of_range& e) {
58513       {
58514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58515       };
58516     } catch (std::exception& e) {
58517       {
58518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58519       };
58520     } catch (Dali::DaliException e) {
58521       {
58522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58523       };
58524     } catch (...) {
58525       {
58526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58527       };
58528     }
58529   }
58530
58531   jresult = (void *)result;
58532   return jresult;
58533 }
58534
58535
58536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58537   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58538
58539   arg1 = (Dali::Timer *)jarg1;
58540   {
58541     try {
58542       delete arg1;
58543     } catch (std::out_of_range& e) {
58544       {
58545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58546       };
58547     } catch (std::exception& e) {
58548       {
58549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58550       };
58551     } catch (Dali::DaliException e) {
58552       {
58553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58554       };
58555     } catch (...) {
58556       {
58557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58558       };
58559     }
58560   }
58561
58562 }
58563
58564
58565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58566   void * jresult ;
58567   Dali::BaseHandle arg1 ;
58568   Dali::BaseHandle *argp1 ;
58569   Dali::Timer result;
58570
58571   argp1 = (Dali::BaseHandle *)jarg1;
58572   if (!argp1) {
58573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58574     return 0;
58575   }
58576   arg1 = *argp1;
58577   {
58578     try {
58579       result = Dali::Timer::DownCast(arg1);
58580     } catch (std::out_of_range& e) {
58581       {
58582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58583       };
58584     } catch (std::exception& e) {
58585       {
58586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58587       };
58588     } catch (Dali::DaliException e) {
58589       {
58590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58591       };
58592     } catch (...) {
58593       {
58594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58595       };
58596     }
58597   }
58598
58599   jresult = new Dali::Timer((const Dali::Timer &)result);
58600   return jresult;
58601 }
58602
58603
58604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58605   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58606
58607   arg1 = (Dali::Timer *)jarg1;
58608   {
58609     try {
58610       (arg1)->Start();
58611     } catch (std::out_of_range& e) {
58612       {
58613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58614       };
58615     } catch (std::exception& e) {
58616       {
58617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58618       };
58619     } catch (Dali::DaliException e) {
58620       {
58621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58622       };
58623     } catch (...) {
58624       {
58625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58626       };
58627     }
58628   }
58629
58630 }
58631
58632
58633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58634   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58635
58636   arg1 = (Dali::Timer *)jarg1;
58637   {
58638     try {
58639       (arg1)->Stop();
58640     } catch (std::out_of_range& e) {
58641       {
58642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58643       };
58644     } catch (std::exception& e) {
58645       {
58646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58647       };
58648     } catch (Dali::DaliException e) {
58649       {
58650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58651       };
58652     } catch (...) {
58653       {
58654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58655       };
58656     }
58657   }
58658
58659 }
58660
58661
58662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58663   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58664   unsigned int arg2 ;
58665
58666   arg1 = (Dali::Timer *)jarg1;
58667   arg2 = (unsigned int)jarg2;
58668   {
58669     try {
58670       (arg1)->SetInterval(arg2);
58671     } catch (std::out_of_range& e) {
58672       {
58673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58674       };
58675     } catch (std::exception& e) {
58676       {
58677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58678       };
58679     } catch (Dali::DaliException e) {
58680       {
58681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58682       };
58683     } catch (...) {
58684       {
58685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58686       };
58687     }
58688   }
58689
58690 }
58691
58692
58693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58694   unsigned int jresult ;
58695   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58696   unsigned int result;
58697
58698   arg1 = (Dali::Timer *)jarg1;
58699   {
58700     try {
58701       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58702     } catch (std::out_of_range& e) {
58703       {
58704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58705       };
58706     } catch (std::exception& e) {
58707       {
58708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58709       };
58710     } catch (Dali::DaliException e) {
58711       {
58712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58713       };
58714     } catch (...) {
58715       {
58716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58717       };
58718     }
58719   }
58720
58721   jresult = result;
58722   return jresult;
58723 }
58724
58725
58726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58727   unsigned int jresult ;
58728   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58729   bool result;
58730
58731   arg1 = (Dali::Timer *)jarg1;
58732   {
58733     try {
58734       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58735     } catch (std::out_of_range& e) {
58736       {
58737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58738       };
58739     } catch (std::exception& e) {
58740       {
58741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58742       };
58743     } catch (Dali::DaliException e) {
58744       {
58745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58746       };
58747     } catch (...) {
58748       {
58749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58750       };
58751     }
58752   }
58753
58754   jresult = result;
58755   return jresult;
58756 }
58757
58758
58759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58760   void * jresult ;
58761   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58762   Dali::Timer::TimerSignalType *result = 0 ;
58763
58764   arg1 = (Dali::Timer *)jarg1;
58765   {
58766     try {
58767       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58768     } catch (std::out_of_range& e) {
58769       {
58770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58771       };
58772     } catch (std::exception& e) {
58773       {
58774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58775       };
58776     } catch (Dali::DaliException e) {
58777       {
58778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58779       };
58780     } catch (...) {
58781       {
58782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58783       };
58784     }
58785   }
58786
58787   jresult = (void *)result;
58788   return jresult;
58789 }
58790
58791
58792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58793   void * jresult ;
58794   Dali::DragAndDropDetector *result = 0 ;
58795
58796   {
58797     try {
58798       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58799     } catch (std::out_of_range& e) {
58800       {
58801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58802       };
58803     } catch (std::exception& e) {
58804       {
58805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58806       };
58807     } catch (Dali::DaliException e) {
58808       {
58809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58810       };
58811     } catch (...) {
58812       {
58813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58814       };
58815     }
58816   }
58817
58818   jresult = (void *)result;
58819   return jresult;
58820 }
58821
58822
58823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58824   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58825
58826   arg1 = (Dali::DragAndDropDetector *)jarg1;
58827   {
58828     try {
58829       delete arg1;
58830     } catch (std::out_of_range& e) {
58831       {
58832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58833       };
58834     } catch (std::exception& e) {
58835       {
58836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58837       };
58838     } catch (Dali::DaliException e) {
58839       {
58840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58841       };
58842     } catch (...) {
58843       {
58844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58845       };
58846     }
58847   }
58848
58849 }
58850
58851
58852 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58853   char * jresult ;
58854   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58855   std::string *result = 0 ;
58856
58857   arg1 = (Dali::DragAndDropDetector *)jarg1;
58858   {
58859     try {
58860       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58861     } catch (std::out_of_range& e) {
58862       {
58863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58864       };
58865     } catch (std::exception& e) {
58866       {
58867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58868       };
58869     } catch (Dali::DaliException e) {
58870       {
58871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58872       };
58873     } catch (...) {
58874       {
58875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58876       };
58877     }
58878   }
58879
58880   jresult = SWIG_csharp_string_callback(result->c_str());
58881   return jresult;
58882 }
58883
58884
58885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58886   void * jresult ;
58887   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58888   Dali::Vector2 result;
58889
58890   arg1 = (Dali::DragAndDropDetector *)jarg1;
58891   {
58892     try {
58893       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58894     } catch (std::out_of_range& e) {
58895       {
58896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58897       };
58898     } catch (std::exception& e) {
58899       {
58900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58901       };
58902     } catch (Dali::DaliException e) {
58903       {
58904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58905       };
58906     } catch (...) {
58907       {
58908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58909       };
58910     }
58911   }
58912
58913   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58914   return jresult;
58915 }
58916
58917
58918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58919   void * jresult ;
58920   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58921   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58922
58923   arg1 = (Dali::DragAndDropDetector *)jarg1;
58924   {
58925     try {
58926       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58927     } catch (std::out_of_range& e) {
58928       {
58929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58930       };
58931     } catch (std::exception& e) {
58932       {
58933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58934       };
58935     } catch (Dali::DaliException e) {
58936       {
58937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58938       };
58939     } catch (...) {
58940       {
58941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58942       };
58943     }
58944   }
58945
58946   jresult = (void *)result;
58947   return jresult;
58948 }
58949
58950
58951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58952   void * jresult ;
58953   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58954   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58955
58956   arg1 = (Dali::DragAndDropDetector *)jarg1;
58957   {
58958     try {
58959       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58960     } catch (std::out_of_range& e) {
58961       {
58962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58963       };
58964     } catch (std::exception& e) {
58965       {
58966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58967       };
58968     } catch (Dali::DaliException e) {
58969       {
58970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58971       };
58972     } catch (...) {
58973       {
58974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58975       };
58976     }
58977   }
58978
58979   jresult = (void *)result;
58980   return jresult;
58981 }
58982
58983
58984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58985   void * jresult ;
58986   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58987   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58988
58989   arg1 = (Dali::DragAndDropDetector *)jarg1;
58990   {
58991     try {
58992       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58993     } catch (std::out_of_range& e) {
58994       {
58995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58996       };
58997     } catch (std::exception& e) {
58998       {
58999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59000       };
59001     } catch (Dali::DaliException e) {
59002       {
59003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59004       };
59005     } catch (...) {
59006       {
59007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59008       };
59009     }
59010   }
59011
59012   jresult = (void *)result;
59013   return jresult;
59014 }
59015
59016
59017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
59018   void * jresult ;
59019   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
59020   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
59021
59022   arg1 = (Dali::DragAndDropDetector *)jarg1;
59023   {
59024     try {
59025       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
59026     } catch (std::out_of_range& e) {
59027       {
59028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59029       };
59030     } catch (std::exception& e) {
59031       {
59032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59033       };
59034     } catch (Dali::DaliException e) {
59035       {
59036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59037       };
59038     } catch (...) {
59039       {
59040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59041       };
59042     }
59043   }
59044
59045   jresult = (void *)result;
59046   return jresult;
59047 }
59048
59049
59050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
59051   void * jresult ;
59052   Dali::ApplicationExtensions *result = 0 ;
59053
59054   {
59055     try {
59056       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
59057     } catch (std::out_of_range& e) {
59058       {
59059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59060       };
59061     } catch (std::exception& e) {
59062       {
59063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59064       };
59065     } catch (Dali::DaliException e) {
59066       {
59067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59068       };
59069     } catch (...) {
59070       {
59071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59072       };
59073     }
59074   }
59075
59076   jresult = (void *)result;
59077   return jresult;
59078 }
59079
59080
59081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59082   void * jresult ;
59083   Dali::Application *arg1 = (Dali::Application *) 0 ;
59084   Dali::ApplicationExtensions *result = 0 ;
59085
59086   arg1 = (Dali::Application *)jarg1;
59087   {
59088     try {
59089       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59090     } catch (std::out_of_range& e) {
59091       {
59092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59093       };
59094     } catch (std::exception& e) {
59095       {
59096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59097       };
59098     } catch (Dali::DaliException e) {
59099       {
59100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59101       };
59102     } catch (...) {
59103       {
59104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59105       };
59106     }
59107   }
59108
59109   jresult = (void *)result;
59110   return jresult;
59111 }
59112
59113
59114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59115   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59116
59117   arg1 = (Dali::ApplicationExtensions *)jarg1;
59118   {
59119     try {
59120       delete arg1;
59121     } catch (std::out_of_range& e) {
59122       {
59123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59124       };
59125     } catch (std::exception& e) {
59126       {
59127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59128       };
59129     } catch (Dali::DaliException e) {
59130       {
59131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59132       };
59133     } catch (...) {
59134       {
59135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59136       };
59137     }
59138   }
59139
59140 }
59141
59142
59143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59144   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59145
59146   arg1 = (Dali::ApplicationExtensions *)jarg1;
59147   {
59148     try {
59149       (arg1)->Init();
59150     } catch (std::out_of_range& e) {
59151       {
59152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59153       };
59154     } catch (std::exception& e) {
59155       {
59156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59157       };
59158     } catch (Dali::DaliException e) {
59159       {
59160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59161       };
59162     } catch (...) {
59163       {
59164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59165       };
59166     }
59167   }
59168
59169 }
59170
59171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59172   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59173
59174   arg1 = (Dali::ApplicationExtensions *)jarg1;
59175   {
59176     try {
59177       (arg1)->Start();
59178     } catch (std::out_of_range& e) {
59179       {
59180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59181       };
59182     } catch (std::exception& e) {
59183       {
59184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59185       };
59186     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59187   }
59188 }
59189
59190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59191   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59192
59193   arg1 = (Dali::ApplicationExtensions *)jarg1;
59194   {
59195     try {
59196       (arg1)->Terminate();
59197     } catch (std::out_of_range& e) {
59198       {
59199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59200       };
59201     } catch (std::exception& e) {
59202       {
59203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59204       };
59205     } catch (Dali::DaliException e) {
59206       {
59207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59208       };
59209     } catch (...) {
59210       {
59211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59212       };
59213     }
59214   }
59215
59216 }
59217
59218
59219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59220   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59221
59222   arg1 = (Dali::ApplicationExtensions *)jarg1;
59223   {
59224     try {
59225       (arg1)->Pause();
59226     } catch (std::out_of_range& e) {
59227       {
59228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59229       };
59230     } catch (std::exception& e) {
59231       {
59232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59233       };
59234     } catch (Dali::DaliException e) {
59235       {
59236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59237       };
59238     } catch (...) {
59239       {
59240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59241       };
59242     }
59243   }
59244
59245 }
59246
59247
59248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59249   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59250
59251   arg1 = (Dali::ApplicationExtensions *)jarg1;
59252   {
59253     try {
59254       (arg1)->Resume();
59255     } catch (std::out_of_range& e) {
59256       {
59257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59258       };
59259     } catch (std::exception& e) {
59260       {
59261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59262       };
59263     } catch (Dali::DaliException e) {
59264       {
59265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59266       };
59267     } catch (...) {
59268       {
59269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59270       };
59271     }
59272   }
59273
59274 }
59275
59276
59277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59278   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59279
59280   arg1 = (Dali::ApplicationExtensions *)jarg1;
59281   {
59282     try {
59283       (arg1)->LanguageChange();
59284     } catch (std::out_of_range& e) {
59285       {
59286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59287       };
59288     } catch (std::exception& e) {
59289       {
59290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59291       };
59292     } catch (Dali::DaliException e) {
59293       {
59294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59295       };
59296     } catch (...) {
59297       {
59298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59299       };
59300     }
59301   }
59302
59303 }
59304
59305
59306
59307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59308   unsigned int jresult ;
59309   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59310   bool result;
59311
59312   arg1 = (Dali::Signal< bool () > *)jarg1;
59313   {
59314     try {
59315       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59316     } catch (std::out_of_range& e) {
59317       {
59318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59319       };
59320     } catch (std::exception& e) {
59321       {
59322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59323       };
59324     } catch (Dali::DaliException e) {
59325       {
59326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59327       };
59328     } catch (...) {
59329       {
59330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59331       };
59332     }
59333   }
59334
59335   jresult = result;
59336   return jresult;
59337 }
59338
59339
59340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59341   unsigned long jresult ;
59342   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59343   std::size_t result;
59344
59345   arg1 = (Dali::Signal< bool () > *)jarg1;
59346   {
59347     try {
59348       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59349     } catch (std::out_of_range& e) {
59350       {
59351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59352       };
59353     } catch (std::exception& e) {
59354       {
59355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59356       };
59357     } catch (Dali::DaliException e) {
59358       {
59359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59360       };
59361     } catch (...) {
59362       {
59363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59364       };
59365     }
59366   }
59367
59368   jresult = (unsigned long)result;
59369   return jresult;
59370 }
59371
59372
59373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59374   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59375   bool (*arg2)() = (bool (*)()) 0 ;
59376
59377   arg1 = (Dali::Signal< bool () > *)jarg1;
59378   arg2 = (bool (*)())jarg2;
59379   {
59380     try {
59381       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59382     } catch (std::out_of_range& e) {
59383       {
59384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59385       };
59386     } catch (std::exception& e) {
59387       {
59388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59389       };
59390     } catch (Dali::DaliException e) {
59391       {
59392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59393       };
59394     } catch (...) {
59395       {
59396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59397       };
59398     }
59399   }
59400
59401 }
59402
59403
59404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59405   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59406   bool (*arg2)() = (bool (*)()) 0 ;
59407
59408   arg1 = (Dali::Signal< bool () > *)jarg1;
59409   arg2 = (bool (*)())jarg2;
59410   {
59411     try {
59412       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59413     } catch (std::out_of_range& e) {
59414       {
59415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59416       };
59417     } catch (std::exception& e) {
59418       {
59419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59420       };
59421     } catch (Dali::DaliException e) {
59422       {
59423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59424       };
59425     } catch (...) {
59426       {
59427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59428       };
59429     }
59430   }
59431
59432 }
59433
59434
59435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59436   unsigned int jresult ;
59437   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59438   bool result;
59439
59440   arg1 = (Dali::Signal< bool () > *)jarg1;
59441   {
59442     try {
59443       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59444     } catch (std::out_of_range& e) {
59445       {
59446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59447       };
59448     } catch (std::exception& e) {
59449       {
59450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59451       };
59452     } catch (Dali::DaliException e) {
59453       {
59454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59455       };
59456     } catch (...) {
59457       {
59458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59459       };
59460     }
59461   }
59462
59463   jresult = result;
59464   return jresult;
59465 }
59466
59467
59468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59469   void * jresult ;
59470   Dali::Signal< bool () > *result = 0 ;
59471
59472   {
59473     try {
59474       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59475     } catch (std::out_of_range& e) {
59476       {
59477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59478       };
59479     } catch (std::exception& e) {
59480       {
59481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59482       };
59483     } catch (Dali::DaliException e) {
59484       {
59485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59486       };
59487     } catch (...) {
59488       {
59489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59490       };
59491     }
59492   }
59493
59494   jresult = (void *)result;
59495   return jresult;
59496 }
59497
59498
59499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59500   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59501
59502   arg1 = (Dali::Signal< bool () > *)jarg1;
59503   {
59504     try {
59505       delete arg1;
59506     } catch (std::out_of_range& e) {
59507       {
59508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59509       };
59510     } catch (std::exception& e) {
59511       {
59512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59513       };
59514     } catch (Dali::DaliException e) {
59515       {
59516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59517       };
59518     } catch (...) {
59519       {
59520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59521       };
59522     }
59523   }
59524
59525 }
59526
59527
59528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59529   int jresult ;
59530   int result;
59531
59532   {
59533     try {
59534       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59535     } catch (std::out_of_range& e) {
59536       {
59537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59538       };
59539     } catch (std::exception& e) {
59540       {
59541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59542       };
59543     } catch (Dali::DaliException e) {
59544       {
59545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59546       };
59547     } catch (...) {
59548       {
59549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59550       };
59551     }
59552   }
59553
59554   jresult = (int)result;
59555   return jresult;
59556 }
59557
59558
59559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59560   int jresult ;
59561   int result;
59562
59563   {
59564     try {
59565       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59566     } catch (std::out_of_range& e) {
59567       {
59568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59569       };
59570     } catch (std::exception& e) {
59571       {
59572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59573       };
59574     } catch (Dali::DaliException e) {
59575       {
59576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59577       };
59578     } catch (...) {
59579       {
59580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59581       };
59582     }
59583   }
59584
59585   jresult = (int)result;
59586   return jresult;
59587 }
59588
59589
59590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59591   int jresult ;
59592   int result;
59593
59594   {
59595     try {
59596       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59597     } catch (std::out_of_range& e) {
59598       {
59599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59600       };
59601     } catch (std::exception& e) {
59602       {
59603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59604       };
59605     } catch (Dali::DaliException e) {
59606       {
59607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59608       };
59609     } catch (...) {
59610       {
59611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59612       };
59613     }
59614   }
59615
59616   jresult = (int)result;
59617   return jresult;
59618 }
59619
59620
59621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59622   int jresult ;
59623   int result;
59624
59625   {
59626     try {
59627       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59628     } catch (std::out_of_range& e) {
59629       {
59630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59631       };
59632     } catch (std::exception& e) {
59633       {
59634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59635       };
59636     } catch (Dali::DaliException e) {
59637       {
59638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59639       };
59640     } catch (...) {
59641       {
59642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59643       };
59644     }
59645   }
59646
59647   jresult = (int)result;
59648   return jresult;
59649 }
59650
59651
59652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59653   int jresult ;
59654   int result;
59655
59656   {
59657     try {
59658       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59659     } catch (std::out_of_range& e) {
59660       {
59661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59662       };
59663     } catch (std::exception& e) {
59664       {
59665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59666       };
59667     } catch (Dali::DaliException e) {
59668       {
59669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59670       };
59671     } catch (...) {
59672       {
59673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59674       };
59675     }
59676   }
59677
59678   jresult = (int)result;
59679   return jresult;
59680 }
59681
59682
59683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59684   int jresult ;
59685   int result;
59686
59687   {
59688     try {
59689       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59690     } catch (std::out_of_range& e) {
59691       {
59692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59693       };
59694     } catch (std::exception& e) {
59695       {
59696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59697       };
59698     } catch (Dali::DaliException e) {
59699       {
59700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59701       };
59702     } catch (...) {
59703       {
59704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59705       };
59706     }
59707   }
59708
59709   jresult = (int)result;
59710   return jresult;
59711 }
59712
59713
59714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59715   int jresult ;
59716   int result;
59717
59718   {
59719     try {
59720       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59721     } catch (std::out_of_range& e) {
59722       {
59723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59724       };
59725     } catch (std::exception& e) {
59726       {
59727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59728       };
59729     } catch (Dali::DaliException e) {
59730       {
59731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59732       };
59733     } catch (...) {
59734       {
59735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59736       };
59737     }
59738   }
59739
59740   jresult = (int)result;
59741   return jresult;
59742 }
59743
59744
59745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59746   int jresult ;
59747   int result;
59748
59749   {
59750     try {
59751       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59752     } catch (std::out_of_range& e) {
59753       {
59754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59755       };
59756     } catch (std::exception& e) {
59757       {
59758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59759       };
59760     } catch (Dali::DaliException e) {
59761       {
59762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59763       };
59764     } catch (...) {
59765       {
59766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59767       };
59768     }
59769   }
59770
59771   jresult = (int)result;
59772   return jresult;
59773 }
59774
59775
59776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59777   int jresult ;
59778   int result;
59779
59780   {
59781     try {
59782       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59783     } catch (std::out_of_range& e) {
59784       {
59785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59786       };
59787     } catch (std::exception& e) {
59788       {
59789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59790       };
59791     } catch (Dali::DaliException e) {
59792       {
59793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59794       };
59795     } catch (...) {
59796       {
59797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59798       };
59799     }
59800   }
59801
59802   jresult = (int)result;
59803   return jresult;
59804 }
59805
59806
59807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59808   int jresult ;
59809   int result;
59810
59811   {
59812     try {
59813       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59814     } catch (std::out_of_range& e) {
59815       {
59816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59817       };
59818     } catch (std::exception& e) {
59819       {
59820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59821       };
59822     } catch (Dali::DaliException e) {
59823       {
59824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59825       };
59826     } catch (...) {
59827       {
59828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59829       };
59830     }
59831   }
59832
59833   jresult = (int)result;
59834   return jresult;
59835 }
59836
59837
59838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59839   int jresult ;
59840   int result;
59841
59842   {
59843     try {
59844       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59845     } catch (std::out_of_range& e) {
59846       {
59847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59848       };
59849     } catch (std::exception& e) {
59850       {
59851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59852       };
59853     } catch (Dali::DaliException e) {
59854       {
59855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59856       };
59857     } catch (...) {
59858       {
59859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59860       };
59861     }
59862   }
59863
59864   jresult = (int)result;
59865   return jresult;
59866 }
59867
59868
59869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59870   int jresult ;
59871   int result;
59872
59873   {
59874     try {
59875       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59876     } catch (std::out_of_range& e) {
59877       {
59878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59879       };
59880     } catch (std::exception& e) {
59881       {
59882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59883       };
59884     } catch (Dali::DaliException e) {
59885       {
59886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59887       };
59888     } catch (...) {
59889       {
59890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59891       };
59892     }
59893   }
59894
59895   jresult = (int)result;
59896   return jresult;
59897 }
59898
59899
59900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59901   int jresult ;
59902   int result;
59903
59904   {
59905     try {
59906       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59907     } catch (std::out_of_range& e) {
59908       {
59909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59910       };
59911     } catch (std::exception& e) {
59912       {
59913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59914       };
59915     } catch (Dali::DaliException e) {
59916       {
59917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59918       };
59919     } catch (...) {
59920       {
59921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59922       };
59923     }
59924   }
59925
59926   jresult = (int)result;
59927   return jresult;
59928 }
59929
59930
59931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59932   int jresult ;
59933   int result;
59934
59935   {
59936     try {
59937       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59938     } catch (std::out_of_range& e) {
59939       {
59940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59941       };
59942     } catch (std::exception& e) {
59943       {
59944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59945       };
59946     } catch (Dali::DaliException e) {
59947       {
59948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59949       };
59950     } catch (...) {
59951       {
59952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59953       };
59954     }
59955   }
59956
59957   jresult = (int)result;
59958   return jresult;
59959 }
59960
59961
59962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59963   int jresult ;
59964   int result;
59965
59966   {
59967     try {
59968       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59969     } catch (std::out_of_range& e) {
59970       {
59971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59972       };
59973     } catch (std::exception& e) {
59974       {
59975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59976       };
59977     } catch (Dali::DaliException e) {
59978       {
59979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59980       };
59981     } catch (...) {
59982       {
59983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59984       };
59985     }
59986   }
59987
59988   jresult = (int)result;
59989   return jresult;
59990 }
59991
59992
59993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59994   int jresult ;
59995   int result;
59996
59997   {
59998     try {
59999       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
60000     } catch (std::out_of_range& e) {
60001       {
60002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60003       };
60004     } catch (std::exception& e) {
60005       {
60006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (Dali::DaliException e) {
60009       {
60010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60011       };
60012     } catch (...) {
60013       {
60014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60015       };
60016     }
60017   }
60018
60019   jresult = (int)result;
60020   return jresult;
60021 }
60022
60023
60024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
60025   int jresult ;
60026   int result;
60027
60028   {
60029     try {
60030       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
60031     } catch (std::out_of_range& e) {
60032       {
60033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60034       };
60035     } catch (std::exception& e) {
60036       {
60037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60038       };
60039     } catch (Dali::DaliException e) {
60040       {
60041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60042       };
60043     } catch (...) {
60044       {
60045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60046       };
60047     }
60048   }
60049
60050   jresult = (int)result;
60051   return jresult;
60052 }
60053
60054
60055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
60056   int jresult ;
60057   int result;
60058
60059   {
60060     try {
60061       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
60062     } catch (std::out_of_range& e) {
60063       {
60064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60065       };
60066     } catch (std::exception& e) {
60067       {
60068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60069       };
60070     } catch (Dali::DaliException e) {
60071       {
60072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60073       };
60074     } catch (...) {
60075       {
60076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60077       };
60078     }
60079   }
60080
60081   jresult = (int)result;
60082   return jresult;
60083 }
60084
60085
60086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60087   int jresult ;
60088   int result;
60089
60090   {
60091     try {
60092       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60093     } catch (std::out_of_range& e) {
60094       {
60095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60096       };
60097     } catch (std::exception& e) {
60098       {
60099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60100       };
60101     } catch (Dali::DaliException e) {
60102       {
60103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60104       };
60105     } catch (...) {
60106       {
60107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60108       };
60109     }
60110   }
60111
60112   jresult = (int)result;
60113   return jresult;
60114 }
60115
60116
60117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60118   int jresult ;
60119   int result;
60120
60121   {
60122     try {
60123       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60124     } catch (std::out_of_range& e) {
60125       {
60126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60127       };
60128     } catch (std::exception& e) {
60129       {
60130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60131       };
60132     } catch (Dali::DaliException e) {
60133       {
60134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60135       };
60136     } catch (...) {
60137       {
60138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60139       };
60140     }
60141   }
60142
60143   jresult = (int)result;
60144   return jresult;
60145 }
60146
60147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60148   int jresult ;
60149   int result;
60150
60151   {
60152     try {
60153       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60154     } catch (std::out_of_range& e) {
60155       {
60156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60157       };
60158     } catch (std::exception& e) {
60159       {
60160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60161       };
60162     } catch (Dali::DaliException e) {
60163       {
60164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60165       };
60166     } catch (...) {
60167       {
60168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60169       };
60170     }
60171   }
60172
60173   jresult = (int)result;
60174   return jresult;
60175 }
60176
60177
60178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60179   int jresult ;
60180   int result;
60181   {
60182     try
60183     {
60184       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60185     } catch (std::out_of_range& e) {
60186       {
60187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60188       };
60189     } catch (std::exception& e) {
60190       {
60191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60192       };
60193     } catch (Dali::DaliException e) {
60194       {
60195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60196       };
60197     } catch (...) {
60198       {
60199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60200       };
60201     }
60202   }
60203
60204   jresult = (int)result;
60205   return jresult;
60206 }
60207
60208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60209   int jresult ;
60210   int result;
60211   {
60212     try
60213     {
60214       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60215     } catch (std::out_of_range& e) {
60216       {
60217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60218       };
60219     } catch (std::exception& e) {
60220       {
60221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60222       };
60223     } catch (Dali::DaliException e) {
60224       {
60225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60226       };
60227     } catch (...) {
60228       {
60229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60230       };
60231     }
60232   }
60233
60234   jresult = (int)result;
60235   return jresult;
60236 }
60237
60238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60239   int jresult ;
60240   int result;
60241   {
60242     try
60243     {
60244       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60245     } catch (std::out_of_range& e) {
60246       {
60247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60248       };
60249     } catch (std::exception& e) {
60250       {
60251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60252       };
60253     } catch (Dali::DaliException e) {
60254       {
60255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60256       };
60257     } catch (...) {
60258       {
60259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60260       };
60261     }
60262   }
60263
60264   jresult = (int)result;
60265   return jresult;
60266 }
60267
60268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
60269   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60270 }
60271
60272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60273   int jresult ;
60274   int result;
60275   {
60276     try
60277     {
60278       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60279     } catch (std::out_of_range& e) {
60280       {
60281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60282       };
60283     } catch (std::exception& e) {
60284       {
60285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60286       };
60287     } catch (Dali::DaliException e) {
60288       {
60289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60290       };
60291     } catch (...) {
60292       {
60293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60294       };
60295     }
60296   }
60297
60298   jresult = (int)result;
60299   return jresult;
60300 }
60301
60302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60303   int jresult ;
60304   int result;
60305   {
60306     try
60307     {
60308       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60309     } catch (std::out_of_range& e) {
60310       {
60311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60312       };
60313     } catch (std::exception& e) {
60314       {
60315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60316       };
60317     } catch (Dali::DaliException e) {
60318       {
60319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60320       };
60321     } catch (...) {
60322       {
60323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60324       };
60325     }
60326   }
60327
60328   jresult = (int)result;
60329   return jresult;
60330 }
60331
60332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60333   int jresult ;
60334   int result;
60335
60336   {
60337     try {
60338       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60339     } catch (std::out_of_range& e) {
60340       {
60341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60342       };
60343     } catch (std::exception& e) {
60344       {
60345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60346       };
60347     } catch (Dali::DaliException e) {
60348       {
60349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60350       };
60351     } catch (...) {
60352       {
60353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60354       };
60355     }
60356   }
60357
60358   jresult = (int)result;
60359   return jresult;
60360 }
60361
60362
60363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60364   int jresult ;
60365   int result;
60366
60367   {
60368     try {
60369       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60370     } catch (std::out_of_range& e) {
60371       {
60372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60373       };
60374     } catch (std::exception& e) {
60375       {
60376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60377       };
60378     } catch (Dali::DaliException e) {
60379       {
60380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60381       };
60382     } catch (...) {
60383       {
60384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60385       };
60386     }
60387   }
60388
60389   jresult = (int)result;
60390   return jresult;
60391 }
60392
60393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60394   int jresult ;
60395   int result;
60396   {
60397     try
60398     {
60399       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60400     } catch (std::out_of_range& e) {
60401       {
60402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60403       };
60404     } catch (std::exception& e) {
60405       {
60406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60407       };
60408     } catch (...) {
60409       {
60410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60411       };
60412     }
60413   }
60414   jresult = (int)result;
60415   return jresult;
60416 }
60417
60418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60419   int jresult ;
60420   int result;
60421   {
60422     try
60423     {
60424       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60425     } catch (std::out_of_range& e) {
60426       {
60427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60428       };
60429     } catch (std::exception& e) {
60430       {
60431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60432       };
60433     } catch (...) {
60434       {
60435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60436       };
60437     }
60438   }
60439   jresult = (int)result;
60440   return jresult;
60441 }
60442
60443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60444   int jresult ;
60445   int result;
60446   {
60447     try
60448     {
60449       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60450     } catch (std::out_of_range& e) {
60451       {
60452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60453       };
60454     } catch (std::exception& e) {
60455       {
60456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60457       };
60458     } catch (...) {
60459       {
60460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60461       };
60462     }
60463   }
60464   jresult = (int)result;
60465   return jresult;
60466 }
60467
60468
60469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60470   int jresult ;
60471   int result;
60472   {
60473     try
60474     {
60475       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60476     } catch (std::out_of_range& e) {
60477       {
60478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60479       };
60480     } catch (std::exception& e) {
60481       {
60482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60483       };
60484     } catch (...) {
60485       {
60486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60487       };
60488     }
60489   }
60490   jresult = (int)result;
60491   return jresult;
60492 }
60493
60494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60495   int jresult ;
60496   int result;
60497   {
60498     try
60499     {
60500       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60501     } catch (std::out_of_range& e) {
60502       {
60503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60504       };
60505     } catch (std::exception& e) {
60506       {
60507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60508       };
60509     } catch (...) {
60510       {
60511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60512       };
60513     }
60514   }
60515   jresult = (int)result;
60516   return jresult;
60517 }
60518
60519
60520
60521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60522   int jresult ;
60523   int result;
60524
60525   {
60526     try {
60527       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60528     } catch (std::out_of_range& e) {
60529       {
60530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60531       };
60532     } catch (std::exception& e) {
60533       {
60534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60535       };
60536     } catch (Dali::DaliException e) {
60537       {
60538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60539       };
60540     } catch (...) {
60541       {
60542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60543       };
60544     }
60545   }
60546
60547   jresult = (int)result;
60548   return jresult;
60549 }
60550
60551
60552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60553   int jresult ;
60554   int result;
60555
60556   {
60557     try {
60558       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60559     } catch (std::out_of_range& e) {
60560       {
60561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60562       };
60563     } catch (std::exception& e) {
60564       {
60565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60566       };
60567     } catch (Dali::DaliException e) {
60568       {
60569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60570       };
60571     } catch (...) {
60572       {
60573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60574       };
60575     }
60576   }
60577
60578   jresult = (int)result;
60579   return jresult;
60580 }
60581
60582
60583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60584   int jresult ;
60585   int result;
60586
60587   {
60588     try {
60589       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60590     } catch (std::out_of_range& e) {
60591       {
60592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60593       };
60594     } catch (std::exception& e) {
60595       {
60596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60597       };
60598     } catch (Dali::DaliException e) {
60599       {
60600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60601       };
60602     } catch (...) {
60603       {
60604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60605       };
60606     }
60607   }
60608
60609   jresult = (int)result;
60610   return jresult;
60611 }
60612
60613
60614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60615   int jresult ;
60616   int result;
60617
60618   {
60619     try {
60620       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
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 (Dali::DaliException e) {
60630       {
60631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60632       };
60633     } catch (...) {
60634       {
60635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60636       };
60637     }
60638   }
60639
60640   jresult = (int)result;
60641   return jresult;
60642 }
60643
60644
60645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60646   int jresult ;
60647   int result;
60648
60649   {
60650     try {
60651       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60652     } catch (std::out_of_range& e) {
60653       {
60654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60655       };
60656     } catch (std::exception& e) {
60657       {
60658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60659       };
60660     } catch (Dali::DaliException e) {
60661       {
60662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60663       };
60664     } catch (...) {
60665       {
60666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60667       };
60668     }
60669   }
60670
60671   jresult = (int)result;
60672   return jresult;
60673 }
60674
60675
60676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60677   int jresult ;
60678   int result;
60679
60680   {
60681     try {
60682       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60683     } catch (std::out_of_range& e) {
60684       {
60685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60686       };
60687     } catch (std::exception& e) {
60688       {
60689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60690       };
60691     } catch (Dali::DaliException e) {
60692       {
60693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60694       };
60695     } catch (...) {
60696       {
60697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60698       };
60699     }
60700   }
60701
60702   jresult = (int)result;
60703   return jresult;
60704 }
60705
60706
60707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60708   int jresult ;
60709   int result;
60710
60711   {
60712     try {
60713       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60714     } catch (std::out_of_range& e) {
60715       {
60716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60717       };
60718     } catch (std::exception& e) {
60719       {
60720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60721       };
60722     } catch (Dali::DaliException e) {
60723       {
60724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60725       };
60726     } catch (...) {
60727       {
60728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60729       };
60730     }
60731   }
60732
60733   jresult = (int)result;
60734   return jresult;
60735 }
60736
60737 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60738   int jresult ;
60739   int result;
60740
60741   {
60742     try {
60743       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60744     } catch (std::out_of_range& e) {
60745       {
60746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60747       };
60748     } catch (std::exception& e) {
60749       {
60750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60751       };
60752     } catch (...) {
60753       {
60754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60755       };
60756     }
60757   }
60758   jresult = (int)result;
60759   return jresult;
60760 }
60761
60762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60763   int jresult ;
60764   int result;
60765
60766   {
60767     try {
60768       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60769     } catch (std::out_of_range& e) {
60770       {
60771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60772       };
60773     } catch (std::exception& e) {
60774       {
60775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60776       };
60777     } catch (Dali::DaliException e) {
60778       {
60779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60780       };
60781     } catch (...) {
60782       {
60783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60784       };
60785     }
60786   }
60787
60788   jresult = (int)result;
60789   return jresult;
60790 }
60791
60792
60793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60794   int jresult ;
60795   int result;
60796
60797   {
60798     try {
60799       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60800     } catch (std::out_of_range& e) {
60801       {
60802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60803       };
60804     } catch (std::exception& e) {
60805       {
60806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60807       };
60808     } catch (Dali::DaliException e) {
60809       {
60810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60811       };
60812     } catch (...) {
60813       {
60814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60815       };
60816     }
60817   }
60818
60819   jresult = (int)result;
60820   return jresult;
60821 }
60822
60823
60824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60825   int jresult ;
60826   int result;
60827
60828   {
60829     try {
60830       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60831     } catch (std::out_of_range& e) {
60832       {
60833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60834       };
60835     } catch (std::exception& e) {
60836       {
60837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60838       };
60839     } catch (Dali::DaliException e) {
60840       {
60841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60842       };
60843     } catch (...) {
60844       {
60845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60846       };
60847     }
60848   }
60849
60850   jresult = (int)result;
60851   return jresult;
60852 }
60853
60854
60855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60856   int jresult ;
60857   int result;
60858
60859   {
60860     try {
60861       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60862     } catch (std::out_of_range& e) {
60863       {
60864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60865       };
60866     } catch (std::exception& e) {
60867       {
60868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60869       };
60870     } catch (Dali::DaliException e) {
60871       {
60872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60873       };
60874     } catch (...) {
60875       {
60876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60877       };
60878     }
60879   }
60880
60881   jresult = (int)result;
60882   return jresult;
60883 }
60884
60885
60886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60887   int jresult ;
60888   int result;
60889
60890   {
60891     try {
60892       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60893     } catch (std::out_of_range& e) {
60894       {
60895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60896       };
60897     } catch (std::exception& e) {
60898       {
60899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60900       };
60901     } catch (Dali::DaliException e) {
60902       {
60903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60904       };
60905     } catch (...) {
60906       {
60907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60908       };
60909     }
60910   }
60911
60912   jresult = (int)result;
60913   return jresult;
60914 }
60915
60916
60917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60918   int jresult ;
60919   int result;
60920
60921   {
60922     try {
60923       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60924     } catch (std::out_of_range& e) {
60925       {
60926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60927       };
60928     } catch (std::exception& e) {
60929       {
60930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60931       };
60932     } catch (Dali::DaliException e) {
60933       {
60934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60935       };
60936     } catch (...) {
60937       {
60938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60939       };
60940     }
60941   }
60942
60943   jresult = (int)result;
60944   return jresult;
60945 }
60946
60947
60948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60949   int jresult ;
60950   int result;
60951
60952   {
60953     try {
60954       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60955     } catch (std::out_of_range& e) {
60956       {
60957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60958       };
60959     } catch (std::exception& e) {
60960       {
60961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60962       };
60963     } catch (Dali::DaliException e) {
60964       {
60965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60966       };
60967     } catch (...) {
60968       {
60969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60970       };
60971     }
60972   }
60973
60974   jresult = (int)result;
60975   return jresult;
60976 }
60977
60978
60979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60980   int jresult ;
60981   int result;
60982
60983   {
60984     try {
60985       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60986     } catch (std::out_of_range& e) {
60987       {
60988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60989       };
60990     } catch (std::exception& e) {
60991       {
60992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60993       };
60994     } catch (Dali::DaliException e) {
60995       {
60996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60997       };
60998     } catch (...) {
60999       {
61000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61001       };
61002     }
61003   }
61004
61005   jresult = (int)result;
61006   return jresult;
61007 }
61008
61009
61010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
61011   int jresult ;
61012   int result;
61013
61014   {
61015     try {
61016       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
61017     } catch (std::out_of_range& e) {
61018       {
61019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61020       };
61021     } catch (std::exception& e) {
61022       {
61023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61024       };
61025     } catch (Dali::DaliException e) {
61026       {
61027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61028       };
61029     } catch (...) {
61030       {
61031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61032       };
61033     }
61034   }
61035
61036   jresult = (int)result;
61037   return jresult;
61038 }
61039
61040
61041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
61042   int jresult ;
61043   int result;
61044
61045   {
61046     try {
61047       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
61048     } catch (std::out_of_range& e) {
61049       {
61050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61051       };
61052     } catch (std::exception& e) {
61053       {
61054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61055       };
61056     } catch (Dali::DaliException e) {
61057       {
61058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61059       };
61060     } catch (...) {
61061       {
61062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61063       };
61064     }
61065   }
61066
61067   jresult = (int)result;
61068   return jresult;
61069 }
61070
61071
61072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61073   int jresult ;
61074   int result;
61075
61076   {
61077     try {
61078       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61079     } catch (std::out_of_range& e) {
61080       {
61081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61082       };
61083     } catch (std::exception& e) {
61084       {
61085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61086       };
61087     } catch (Dali::DaliException e) {
61088       {
61089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61090       };
61091     } catch (...) {
61092       {
61093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61094       };
61095     }
61096   }
61097
61098   jresult = (int)result;
61099   return jresult;
61100 }
61101
61102
61103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61104   int jresult ;
61105   int result;
61106
61107   {
61108     try {
61109       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61110     } catch (std::out_of_range& e) {
61111       {
61112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61113       };
61114     } catch (std::exception& e) {
61115       {
61116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61117       };
61118     } catch (Dali::DaliException e) {
61119       {
61120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61121       };
61122     } catch (...) {
61123       {
61124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61125       };
61126     }
61127   }
61128
61129   jresult = (int)result;
61130   return jresult;
61131 }
61132
61133
61134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61135   int jresult ;
61136   int result;
61137
61138   {
61139     try {
61140       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61141     } catch (std::out_of_range& e) {
61142       {
61143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61144       };
61145     } catch (std::exception& e) {
61146       {
61147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61148       };
61149     } catch (Dali::DaliException e) {
61150       {
61151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61152       };
61153     } catch (...) {
61154       {
61155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61156       };
61157     }
61158   }
61159
61160   jresult = (int)result;
61161   return jresult;
61162 }
61163
61164
61165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61166   int jresult ;
61167   int result;
61168
61169   {
61170     try {
61171       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61172     } catch (std::out_of_range& e) {
61173       {
61174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61175       };
61176     } catch (std::exception& e) {
61177       {
61178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61179       };
61180     } catch (Dali::DaliException e) {
61181       {
61182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61183       };
61184     } catch (...) {
61185       {
61186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61187       };
61188     }
61189   }
61190
61191   jresult = (int)result;
61192   return jresult;
61193 }
61194
61195
61196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61197   int jresult ;
61198   int result;
61199
61200   {
61201     try {
61202       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61203     } catch (std::out_of_range& e) {
61204       {
61205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61206       };
61207     } catch (std::exception& e) {
61208       {
61209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61210       };
61211     } catch (Dali::DaliException e) {
61212       {
61213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61214       };
61215     } catch (...) {
61216       {
61217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61218       };
61219     }
61220   }
61221
61222   jresult = (int)result;
61223   return jresult;
61224 }
61225
61226
61227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61228   int jresult ;
61229   int result;
61230
61231   {
61232     try {
61233       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61234     } catch (std::out_of_range& e) {
61235       {
61236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61237       };
61238     } catch (std::exception& e) {
61239       {
61240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61241       };
61242     } catch (Dali::DaliException e) {
61243       {
61244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61245       };
61246     } catch (...) {
61247       {
61248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61249       };
61250     }
61251   }
61252
61253   jresult = (int)result;
61254   return jresult;
61255 }
61256
61257
61258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61259   int jresult ;
61260   int result;
61261
61262   {
61263     try {
61264       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61265     } catch (std::out_of_range& e) {
61266       {
61267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61268       };
61269     } catch (std::exception& e) {
61270       {
61271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61272       };
61273     } catch (Dali::DaliException e) {
61274       {
61275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61276       };
61277     } catch (...) {
61278       {
61279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61280       };
61281     }
61282   }
61283
61284   jresult = (int)result;
61285   return jresult;
61286 }
61287
61288
61289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61290   int jresult ;
61291   int result;
61292
61293   {
61294     try {
61295       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61296     } catch (std::out_of_range& e) {
61297       {
61298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61299       };
61300     } catch (std::exception& e) {
61301       {
61302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61303       };
61304     } catch (Dali::DaliException e) {
61305       {
61306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61307       };
61308     } catch (...) {
61309       {
61310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61311       };
61312     }
61313   }
61314
61315   jresult = (int)result;
61316   return jresult;
61317 }
61318
61319
61320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61321   int jresult ;
61322   int result;
61323
61324   {
61325     try {
61326       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61327     } catch (std::out_of_range& e) {
61328       {
61329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61330       };
61331     } catch (std::exception& e) {
61332       {
61333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61334       };
61335     } catch (Dali::DaliException e) {
61336       {
61337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61338       };
61339     } catch (...) {
61340       {
61341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61342       };
61343     }
61344   }
61345
61346   jresult = (int)result;
61347   return jresult;
61348 }
61349
61350
61351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61352   int jresult ;
61353   int result;
61354
61355   {
61356     try {
61357       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61358     } catch (std::out_of_range& e) {
61359       {
61360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61361       };
61362     } catch (std::exception& e) {
61363       {
61364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61365       };
61366     } catch (Dali::DaliException e) {
61367       {
61368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61369       };
61370     } catch (...) {
61371       {
61372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61373       };
61374     }
61375   }
61376
61377   jresult = (int)result;
61378   return jresult;
61379 }
61380
61381
61382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61383   int jresult ;
61384   int result;
61385
61386   {
61387     try {
61388       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61389     } catch (std::out_of_range& e) {
61390       {
61391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61392       };
61393     } catch (std::exception& e) {
61394       {
61395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61396       };
61397     } catch (Dali::DaliException e) {
61398       {
61399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61400       };
61401     } catch (...) {
61402       {
61403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61404       };
61405     }
61406   }
61407
61408   jresult = (int)result;
61409   return jresult;
61410 }
61411
61412
61413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61414   int jresult ;
61415   int result;
61416
61417   {
61418     try {
61419       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61420     } catch (std::out_of_range& e) {
61421       {
61422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61423       };
61424     } catch (std::exception& e) {
61425       {
61426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61427       };
61428     } catch (Dali::DaliException e) {
61429       {
61430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61431       };
61432     } catch (...) {
61433       {
61434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61435       };
61436     }
61437   }
61438
61439   jresult = (int)result;
61440   return jresult;
61441 }
61442
61443
61444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61445   int jresult ;
61446   int result;
61447
61448   {
61449     try {
61450       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61451     } catch (std::out_of_range& e) {
61452       {
61453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61454       };
61455     } catch (std::exception& e) {
61456       {
61457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61458       };
61459     } catch (Dali::DaliException e) {
61460       {
61461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61462       };
61463     } catch (...) {
61464       {
61465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61466       };
61467     }
61468   }
61469
61470   jresult = (int)result;
61471   return jresult;
61472 }
61473
61474
61475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61476   int jresult ;
61477   int result;
61478
61479   {
61480     try {
61481       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61482     } catch (std::out_of_range& e) {
61483       {
61484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61485       };
61486     } catch (std::exception& e) {
61487       {
61488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61489       };
61490     } catch (Dali::DaliException e) {
61491       {
61492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61493       };
61494     } catch (...) {
61495       {
61496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61497       };
61498     }
61499   }
61500
61501   jresult = (int)result;
61502   return jresult;
61503 }
61504
61505
61506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61507   int jresult ;
61508   int result;
61509
61510   {
61511     try {
61512       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61513     } catch (std::out_of_range& e) {
61514       {
61515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61516       };
61517     } catch (std::exception& e) {
61518       {
61519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61520       };
61521     } catch (Dali::DaliException e) {
61522       {
61523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61524       };
61525     } catch (...) {
61526       {
61527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61528       };
61529     }
61530   }
61531
61532   jresult = (int)result;
61533   return jresult;
61534 }
61535
61536
61537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61538   int jresult ;
61539   int result;
61540
61541   {
61542     try {
61543       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61544     } catch (std::out_of_range& e) {
61545       {
61546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61547       };
61548     } catch (std::exception& e) {
61549       {
61550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61551       };
61552     } catch (Dali::DaliException e) {
61553       {
61554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61555       };
61556     } catch (...) {
61557       {
61558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61559       };
61560     }
61561   }
61562
61563   jresult = (int)result;
61564   return jresult;
61565 }
61566
61567
61568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61569   int jresult ;
61570   int result;
61571
61572   {
61573     try {
61574       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61575     } catch (std::out_of_range& e) {
61576       {
61577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61578       };
61579     } catch (std::exception& e) {
61580       {
61581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61582       };
61583     } catch (Dali::DaliException e) {
61584       {
61585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61586       };
61587     } catch (...) {
61588       {
61589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61590       };
61591     }
61592   }
61593
61594   jresult = (int)result;
61595   return jresult;
61596 }
61597
61598
61599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61600   int jresult ;
61601   int result;
61602
61603   {
61604     try {
61605       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61606     } catch (std::out_of_range& e) {
61607       {
61608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61609       };
61610     } catch (std::exception& e) {
61611       {
61612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61613       };
61614     } catch (Dali::DaliException e) {
61615       {
61616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61617       };
61618     } catch (...) {
61619       {
61620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61621       };
61622     }
61623   }
61624
61625   jresult = (int)result;
61626   return jresult;
61627 }
61628
61629
61630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61631   void * jresult ;
61632   Dali::Toolkit::Builder *result = 0 ;
61633
61634   {
61635     try {
61636       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61637     } catch (std::out_of_range& e) {
61638       {
61639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61640       };
61641     } catch (std::exception& e) {
61642       {
61643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61644       };
61645     } catch (Dali::DaliException e) {
61646       {
61647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61648       };
61649     } catch (...) {
61650       {
61651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61652       };
61653     }
61654   }
61655
61656   jresult = (void *)result;
61657   return jresult;
61658 }
61659
61660
61661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61662   void * jresult ;
61663   Dali::Toolkit::Builder result;
61664
61665   {
61666     try {
61667       result = Dali::Toolkit::Builder::New();
61668     } catch (std::out_of_range& e) {
61669       {
61670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61671       };
61672     } catch (std::exception& e) {
61673       {
61674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61675       };
61676     } catch (Dali::DaliException e) {
61677       {
61678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61679       };
61680     } catch (...) {
61681       {
61682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61683       };
61684     }
61685   }
61686
61687   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61688   return jresult;
61689 }
61690
61691
61692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61693   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61694
61695   arg1 = (Dali::Toolkit::Builder *)jarg1;
61696   {
61697     try {
61698       delete arg1;
61699     } catch (std::out_of_range& e) {
61700       {
61701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61702       };
61703     } catch (std::exception& e) {
61704       {
61705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61706       };
61707     } catch (Dali::DaliException e) {
61708       {
61709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61710       };
61711     } catch (...) {
61712       {
61713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61714       };
61715     }
61716   }
61717
61718 }
61719
61720
61721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61722   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61723   std::string *arg2 = 0 ;
61724   Dali::Toolkit::Builder::UIFormat arg3 ;
61725
61726   arg1 = (Dali::Toolkit::Builder *)jarg1;
61727   if (!jarg2) {
61728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61729     return ;
61730   }
61731   std::string arg2_str(jarg2);
61732   arg2 = &arg2_str;
61733   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61734   {
61735     try {
61736       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61737     } catch (std::out_of_range& e) {
61738       {
61739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61740       };
61741     } catch (std::exception& e) {
61742       {
61743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61744       };
61745     } catch (Dali::DaliException e) {
61746       {
61747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61748       };
61749     } catch (...) {
61750       {
61751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61752       };
61753     }
61754   }
61755
61756
61757   //argout typemap for const std::string&
61758
61759 }
61760
61761
61762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61763   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61764   std::string *arg2 = 0 ;
61765
61766   arg1 = (Dali::Toolkit::Builder *)jarg1;
61767   if (!jarg2) {
61768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61769     return ;
61770   }
61771   std::string arg2_str(jarg2);
61772   arg2 = &arg2_str;
61773   {
61774     try {
61775       (arg1)->LoadFromString((std::string const &)*arg2);
61776     } catch (std::out_of_range& e) {
61777       {
61778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61779       };
61780     } catch (std::exception& e) {
61781       {
61782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61783       };
61784     } catch (Dali::DaliException e) {
61785       {
61786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61787       };
61788     } catch (...) {
61789       {
61790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61791       };
61792     }
61793   }
61794
61795
61796   //argout typemap for const std::string&
61797
61798 }
61799
61800
61801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61802   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61803   Dali::Property::Map *arg2 = 0 ;
61804
61805   arg1 = (Dali::Toolkit::Builder *)jarg1;
61806   arg2 = (Dali::Property::Map *)jarg2;
61807   if (!arg2) {
61808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61809     return ;
61810   }
61811   {
61812     try {
61813       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61814     } catch (std::out_of_range& e) {
61815       {
61816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61817       };
61818     } catch (std::exception& e) {
61819       {
61820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61821       };
61822     } catch (Dali::DaliException e) {
61823       {
61824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61825       };
61826     } catch (...) {
61827       {
61828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61829       };
61830     }
61831   }
61832
61833 }
61834
61835
61836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61837   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61838   std::string *arg2 = 0 ;
61839   Dali::Property::Value *arg3 = 0 ;
61840
61841   arg1 = (Dali::Toolkit::Builder *)jarg1;
61842   if (!jarg2) {
61843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61844     return ;
61845   }
61846   std::string arg2_str(jarg2);
61847   arg2 = &arg2_str;
61848   arg3 = (Dali::Property::Value *)jarg3;
61849   if (!arg3) {
61850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61851     return ;
61852   }
61853   {
61854     try {
61855       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61856     } catch (std::out_of_range& e) {
61857       {
61858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61859       };
61860     } catch (std::exception& e) {
61861       {
61862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61863       };
61864     } catch (Dali::DaliException e) {
61865       {
61866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61867       };
61868     } catch (...) {
61869       {
61870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61871       };
61872     }
61873   }
61874
61875
61876   //argout typemap for const std::string&
61877
61878 }
61879
61880
61881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61882   void * jresult ;
61883   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61884   Dali::Property::Map *result = 0 ;
61885
61886   arg1 = (Dali::Toolkit::Builder *)jarg1;
61887   {
61888     try {
61889       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61890     } catch (std::out_of_range& e) {
61891       {
61892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61893       };
61894     } catch (std::exception& e) {
61895       {
61896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61897       };
61898     } catch (Dali::DaliException e) {
61899       {
61900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61901       };
61902     } catch (...) {
61903       {
61904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61905       };
61906     }
61907   }
61908
61909   jresult = (void *)result;
61910   return jresult;
61911 }
61912
61913
61914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61915   void * jresult ;
61916   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61917   std::string *arg2 = 0 ;
61918   Dali::Property::Value *result = 0 ;
61919
61920   arg1 = (Dali::Toolkit::Builder *)jarg1;
61921   if (!jarg2) {
61922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61923     return 0;
61924   }
61925   std::string arg2_str(jarg2);
61926   arg2 = &arg2_str;
61927   {
61928     try {
61929       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61930     } catch (std::out_of_range& e) {
61931       {
61932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61933       };
61934     } catch (std::exception& e) {
61935       {
61936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61937       };
61938     } catch (Dali::DaliException e) {
61939       {
61940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61941       };
61942     } catch (...) {
61943       {
61944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61945       };
61946     }
61947   }
61948
61949   jresult = (void *)result;
61950
61951   //argout typemap for const std::string&
61952
61953   return jresult;
61954 }
61955
61956
61957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61958   void * jresult ;
61959   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61960   std::string *arg2 = 0 ;
61961   Dali::Animation result;
61962
61963   arg1 = (Dali::Toolkit::Builder *)jarg1;
61964   if (!jarg2) {
61965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61966     return 0;
61967   }
61968   std::string arg2_str(jarg2);
61969   arg2 = &arg2_str;
61970   {
61971     try {
61972       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61973     } catch (std::out_of_range& e) {
61974       {
61975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61976       };
61977     } catch (std::exception& e) {
61978       {
61979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61980       };
61981     } catch (Dali::DaliException e) {
61982       {
61983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61984       };
61985     } catch (...) {
61986       {
61987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61988       };
61989     }
61990   }
61991
61992   jresult = new Dali::Animation((const Dali::Animation &)result);
61993
61994   //argout typemap for const std::string&
61995
61996   return jresult;
61997 }
61998
61999
62000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62001   void * jresult ;
62002   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62003   std::string *arg2 = 0 ;
62004   Dali::Property::Map *arg3 = 0 ;
62005   Dali::Animation result;
62006
62007   arg1 = (Dali::Toolkit::Builder *)jarg1;
62008   if (!jarg2) {
62009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62010     return 0;
62011   }
62012   std::string arg2_str(jarg2);
62013   arg2 = &arg2_str;
62014   arg3 = (Dali::Property::Map *)jarg3;
62015   if (!arg3) {
62016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62017     return 0;
62018   }
62019   {
62020     try {
62021       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62022     } catch (std::out_of_range& e) {
62023       {
62024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62025       };
62026     } catch (std::exception& e) {
62027       {
62028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62029       };
62030     } catch (Dali::DaliException e) {
62031       {
62032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62033       };
62034     } catch (...) {
62035       {
62036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62037       };
62038     }
62039   }
62040
62041   jresult = new Dali::Animation((const Dali::Animation &)result);
62042
62043   //argout typemap for const std::string&
62044
62045   return jresult;
62046 }
62047
62048
62049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62050   void * jresult ;
62051   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62052   std::string *arg2 = 0 ;
62053   Dali::Actor arg3 ;
62054   Dali::Actor *argp3 ;
62055   Dali::Animation result;
62056
62057   arg1 = (Dali::Toolkit::Builder *)jarg1;
62058   if (!jarg2) {
62059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62060     return 0;
62061   }
62062   std::string arg2_str(jarg2);
62063   arg2 = &arg2_str;
62064   argp3 = (Dali::Actor *)jarg3;
62065   if (!argp3) {
62066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62067     return 0;
62068   }
62069   arg3 = *argp3;
62070   {
62071     try {
62072       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62073     } catch (std::out_of_range& e) {
62074       {
62075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62076       };
62077     } catch (std::exception& e) {
62078       {
62079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62080       };
62081     } catch (Dali::DaliException e) {
62082       {
62083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62084       };
62085     } catch (...) {
62086       {
62087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62088       };
62089     }
62090   }
62091
62092   jresult = new Dali::Animation((const Dali::Animation &)result);
62093
62094   //argout typemap for const std::string&
62095
62096   return jresult;
62097 }
62098
62099
62100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62101   void * jresult ;
62102   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62103   std::string *arg2 = 0 ;
62104   Dali::Property::Map *arg3 = 0 ;
62105   Dali::Actor arg4 ;
62106   Dali::Actor *argp4 ;
62107   Dali::Animation result;
62108
62109   arg1 = (Dali::Toolkit::Builder *)jarg1;
62110   if (!jarg2) {
62111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62112     return 0;
62113   }
62114   std::string arg2_str(jarg2);
62115   arg2 = &arg2_str;
62116   arg3 = (Dali::Property::Map *)jarg3;
62117   if (!arg3) {
62118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62119     return 0;
62120   }
62121   argp4 = (Dali::Actor *)jarg4;
62122   if (!argp4) {
62123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62124     return 0;
62125   }
62126   arg4 = *argp4;
62127   {
62128     try {
62129       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62130     } catch (std::out_of_range& e) {
62131       {
62132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62133       };
62134     } catch (std::exception& e) {
62135       {
62136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62137       };
62138     } catch (Dali::DaliException e) {
62139       {
62140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62141       };
62142     } catch (...) {
62143       {
62144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62145       };
62146     }
62147   }
62148
62149   jresult = new Dali::Animation((const Dali::Animation &)result);
62150
62151   //argout typemap for const std::string&
62152
62153   return jresult;
62154 }
62155
62156
62157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62158   void * jresult ;
62159   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62160   std::string *arg2 = 0 ;
62161   Dali::BaseHandle result;
62162
62163   arg1 = (Dali::Toolkit::Builder *)jarg1;
62164   if (!jarg2) {
62165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62166     return 0;
62167   }
62168   std::string arg2_str(jarg2);
62169   arg2 = &arg2_str;
62170   {
62171     try {
62172       result = (arg1)->Create((std::string const &)*arg2);
62173     } catch (std::out_of_range& e) {
62174       {
62175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62176       };
62177     } catch (std::exception& e) {
62178       {
62179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62180       };
62181     } catch (Dali::DaliException e) {
62182       {
62183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62184       };
62185     } catch (...) {
62186       {
62187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62188       };
62189     }
62190   }
62191
62192   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62193
62194   //argout typemap for const std::string&
62195
62196   return jresult;
62197 }
62198
62199
62200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62201   void * jresult ;
62202   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62203   std::string *arg2 = 0 ;
62204   Dali::Property::Map *arg3 = 0 ;
62205   Dali::BaseHandle result;
62206
62207   arg1 = (Dali::Toolkit::Builder *)jarg1;
62208   if (!jarg2) {
62209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62210     return 0;
62211   }
62212   std::string arg2_str(jarg2);
62213   arg2 = &arg2_str;
62214   arg3 = (Dali::Property::Map *)jarg3;
62215   if (!arg3) {
62216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62217     return 0;
62218   }
62219   {
62220     try {
62221       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62222     } catch (std::out_of_range& e) {
62223       {
62224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62225       };
62226     } catch (std::exception& e) {
62227       {
62228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62229       };
62230     } catch (Dali::DaliException e) {
62231       {
62232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62233       };
62234     } catch (...) {
62235       {
62236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62237       };
62238     }
62239   }
62240
62241   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62242
62243   //argout typemap for const std::string&
62244
62245   return jresult;
62246 }
62247
62248
62249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62250   void * jresult ;
62251   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62252   std::string *arg2 = 0 ;
62253   Dali::BaseHandle result;
62254
62255   arg1 = (Dali::Toolkit::Builder *)jarg1;
62256   if (!jarg2) {
62257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62258     return 0;
62259   }
62260   std::string arg2_str(jarg2);
62261   arg2 = &arg2_str;
62262   {
62263     try {
62264       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62265     } catch (std::out_of_range& e) {
62266       {
62267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62268       };
62269     } catch (std::exception& e) {
62270       {
62271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62272       };
62273     } catch (Dali::DaliException e) {
62274       {
62275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62276       };
62277     } catch (...) {
62278       {
62279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62280       };
62281     }
62282   }
62283
62284   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62285
62286   //argout typemap for const std::string&
62287
62288   return jresult;
62289 }
62290
62291
62292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62293   unsigned int jresult ;
62294   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62295   std::string *arg2 = 0 ;
62296   Dali::Handle *arg3 = 0 ;
62297   bool result;
62298
62299   arg1 = (Dali::Toolkit::Builder *)jarg1;
62300   if (!jarg2) {
62301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62302     return 0;
62303   }
62304   std::string arg2_str(jarg2);
62305   arg2 = &arg2_str;
62306   arg3 = (Dali::Handle *)jarg3;
62307   if (!arg3) {
62308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62309     return 0;
62310   }
62311   {
62312     try {
62313       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62314     } catch (std::out_of_range& e) {
62315       {
62316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62317       };
62318     } catch (std::exception& e) {
62319       {
62320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (Dali::DaliException e) {
62323       {
62324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62325       };
62326     } catch (...) {
62327       {
62328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62329       };
62330     }
62331   }
62332
62333   jresult = result;
62334
62335   //argout typemap for const std::string&
62336
62337   return jresult;
62338 }
62339
62340
62341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62342   unsigned int jresult ;
62343   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62344   Dali::Handle *arg2 = 0 ;
62345   std::string *arg3 = 0 ;
62346   bool result;
62347
62348   arg1 = (Dali::Toolkit::Builder *)jarg1;
62349   arg2 = (Dali::Handle *)jarg2;
62350   if (!arg2) {
62351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62352     return 0;
62353   }
62354   if (!jarg3) {
62355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62356     return 0;
62357   }
62358   std::string arg3_str(jarg3);
62359   arg3 = &arg3_str;
62360   {
62361     try {
62362       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62363     } catch (std::out_of_range& e) {
62364       {
62365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62366       };
62367     } catch (std::exception& e) {
62368       {
62369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62370       };
62371     } catch (Dali::DaliException e) {
62372       {
62373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62374       };
62375     } catch (...) {
62376       {
62377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62378       };
62379     }
62380   }
62381
62382   jresult = result;
62383
62384   //argout typemap for const std::string&
62385
62386   return jresult;
62387 }
62388
62389
62390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62391   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62392   Dali::Actor arg2 ;
62393   Dali::Actor *argp2 ;
62394
62395   arg1 = (Dali::Toolkit::Builder *)jarg1;
62396   argp2 = (Dali::Actor *)jarg2;
62397   if (!argp2) {
62398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62399     return ;
62400   }
62401   arg2 = *argp2;
62402   {
62403     try {
62404       (arg1)->AddActors(arg2);
62405     } catch (std::out_of_range& e) {
62406       {
62407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62408       };
62409     } catch (std::exception& e) {
62410       {
62411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62412       };
62413     } catch (Dali::DaliException e) {
62414       {
62415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62416       };
62417     } catch (...) {
62418       {
62419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62420       };
62421     }
62422   }
62423
62424 }
62425
62426
62427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62428   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62429   std::string *arg2 = 0 ;
62430   Dali::Actor arg3 ;
62431   Dali::Actor *argp3 ;
62432
62433   arg1 = (Dali::Toolkit::Builder *)jarg1;
62434   if (!jarg2) {
62435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62436     return ;
62437   }
62438   std::string arg2_str(jarg2);
62439   arg2 = &arg2_str;
62440   argp3 = (Dali::Actor *)jarg3;
62441   if (!argp3) {
62442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62443     return ;
62444   }
62445   arg3 = *argp3;
62446   {
62447     try {
62448       (arg1)->AddActors((std::string const &)*arg2,arg3);
62449     } catch (std::out_of_range& e) {
62450       {
62451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62452       };
62453     } catch (std::exception& e) {
62454       {
62455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62456       };
62457     } catch (Dali::DaliException e) {
62458       {
62459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62460       };
62461     } catch (...) {
62462       {
62463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62464       };
62465     }
62466   }
62467
62468
62469   //argout typemap for const std::string&
62470
62471 }
62472
62473
62474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62475   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62476   std::string *arg2 = 0 ;
62477
62478   arg1 = (Dali::Toolkit::Builder *)jarg1;
62479   if (!jarg2) {
62480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62481     return ;
62482   }
62483   std::string arg2_str(jarg2);
62484   arg2 = &arg2_str;
62485   {
62486     try {
62487       (arg1)->CreateRenderTask((std::string const &)*arg2);
62488     } catch (std::out_of_range& e) {
62489       {
62490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62491       };
62492     } catch (std::exception& e) {
62493       {
62494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62495       };
62496     } catch (Dali::DaliException e) {
62497       {
62498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62499       };
62500     } catch (...) {
62501       {
62502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62503       };
62504     }
62505   }
62506
62507
62508   //argout typemap for const std::string&
62509
62510 }
62511
62512
62513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62514   void * jresult ;
62515   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62516   std::string *arg2 = 0 ;
62517   Dali::FrameBufferImage result;
62518
62519   arg1 = (Dali::Toolkit::Builder *)jarg1;
62520   if (!jarg2) {
62521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62522     return 0;
62523   }
62524   std::string arg2_str(jarg2);
62525   arg2 = &arg2_str;
62526   {
62527     try {
62528       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62529     } catch (std::out_of_range& e) {
62530       {
62531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62532       };
62533     } catch (std::exception& e) {
62534       {
62535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62536       };
62537     } catch (Dali::DaliException e) {
62538       {
62539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62540       };
62541     } catch (...) {
62542       {
62543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62544       };
62545     }
62546   }
62547
62548   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62549
62550   //argout typemap for const std::string&
62551
62552   return jresult;
62553 }
62554
62555
62556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62557   void * jresult ;
62558   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62559   std::string *arg2 = 0 ;
62560   Dali::Path result;
62561
62562   arg1 = (Dali::Toolkit::Builder *)jarg1;
62563   if (!jarg2) {
62564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62565     return 0;
62566   }
62567   std::string arg2_str(jarg2);
62568   arg2 = &arg2_str;
62569   {
62570     try {
62571       result = (arg1)->GetPath((std::string const &)*arg2);
62572     } catch (std::out_of_range& e) {
62573       {
62574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62575       };
62576     } catch (std::exception& e) {
62577       {
62578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62579       };
62580     } catch (Dali::DaliException e) {
62581       {
62582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62583       };
62584     } catch (...) {
62585       {
62586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62587       };
62588     }
62589   }
62590
62591   jresult = new Dali::Path((const Dali::Path &)result);
62592
62593   //argout typemap for const std::string&
62594
62595   return jresult;
62596 }
62597
62598
62599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62600   void * jresult ;
62601   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62602   std::string *arg2 = 0 ;
62603   Dali::PathConstrainer result;
62604
62605   arg1 = (Dali::Toolkit::Builder *)jarg1;
62606   if (!jarg2) {
62607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62608     return 0;
62609   }
62610   std::string arg2_str(jarg2);
62611   arg2 = &arg2_str;
62612   {
62613     try {
62614       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62615     } catch (std::out_of_range& e) {
62616       {
62617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62618       };
62619     } catch (std::exception& e) {
62620       {
62621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62622       };
62623     } catch (Dali::DaliException e) {
62624       {
62625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62626       };
62627     } catch (...) {
62628       {
62629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62630       };
62631     }
62632   }
62633
62634   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62635
62636   //argout typemap for const std::string&
62637
62638   return jresult;
62639 }
62640
62641
62642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62643   void * jresult ;
62644   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62645   std::string *arg2 = 0 ;
62646   Dali::LinearConstrainer result;
62647
62648   arg1 = (Dali::Toolkit::Builder *)jarg1;
62649   if (!jarg2) {
62650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62651     return 0;
62652   }
62653   std::string arg2_str(jarg2);
62654   arg2 = &arg2_str;
62655   {
62656     try {
62657       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62658     } catch (std::out_of_range& e) {
62659       {
62660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62661       };
62662     } catch (std::exception& e) {
62663       {
62664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62665       };
62666     } catch (Dali::DaliException e) {
62667       {
62668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62669       };
62670     } catch (...) {
62671       {
62672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62673       };
62674     }
62675   }
62676
62677   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62678
62679   //argout typemap for const std::string&
62680
62681   return jresult;
62682 }
62683
62684
62685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62686   void * jresult ;
62687   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62688   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62689
62690   arg1 = (Dali::Toolkit::Builder *)jarg1;
62691   {
62692     try {
62693       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62694     } catch (std::out_of_range& e) {
62695       {
62696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62697       };
62698     } catch (std::exception& e) {
62699       {
62700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62701       };
62702     } catch (Dali::DaliException e) {
62703       {
62704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62705       };
62706     } catch (...) {
62707       {
62708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62709       };
62710     }
62711   }
62712
62713   jresult = (void *)result;
62714   return jresult;
62715 }
62716
62717
62718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62719   void * jresult ;
62720   Dali::Toolkit::TransitionData *result = 0 ;
62721
62722   {
62723     try {
62724       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62725     } catch (std::out_of_range& e) {
62726       {
62727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62728       };
62729     } catch (std::exception& e) {
62730       {
62731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62732       };
62733     } catch (Dali::DaliException e) {
62734       {
62735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62736       };
62737     } catch (...) {
62738       {
62739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62740       };
62741     }
62742   }
62743
62744   jresult = (void *)result;
62745   return jresult;
62746 }
62747
62748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62749   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62750
62751   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62752   {
62753     try {
62754       delete arg1;
62755     } catch (std::out_of_range& e) {
62756       {
62757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62758       };
62759     } catch (std::exception& e) {
62760       {
62761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62762       };
62763     } catch (Dali::DaliException e) {
62764       {
62765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62766       };
62767     } catch (...) {
62768       {
62769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62770       };
62771     }
62772   }
62773
62774 }
62775
62776
62777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62778   void * jresult ;
62779   Dali::Property::Map *arg1 = 0 ;
62780   Dali::Toolkit::TransitionData result;
62781
62782   arg1 = (Dali::Property::Map *)jarg1;
62783   if (!arg1) {
62784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62785     return 0;
62786   }
62787   {
62788     try {
62789       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62790     } catch (std::out_of_range& e) {
62791       {
62792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62793       };
62794     } catch (std::exception& e) {
62795       {
62796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62797       };
62798     } catch (Dali::DaliException e) {
62799       {
62800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62801       };
62802     } catch (...) {
62803       {
62804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62805       };
62806     }
62807   }
62808
62809   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62810   return jresult;
62811 }
62812
62813
62814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62815   void * jresult ;
62816   Dali::Property::Array *arg1 = 0 ;
62817   Dali::Toolkit::TransitionData result;
62818
62819   arg1 = (Dali::Property::Array *)jarg1;
62820   if (!arg1) {
62821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62822     return 0;
62823   }
62824   {
62825     try {
62826       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62827     } catch (std::out_of_range& e) {
62828       {
62829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62830       };
62831     } catch (std::exception& e) {
62832       {
62833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62834       };
62835     } catch (Dali::DaliException e) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62838       };
62839     } catch (...) {
62840       {
62841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62842       };
62843     }
62844   }
62845
62846   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62847   return jresult;
62848 }
62849
62850
62851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62852   void * jresult ;
62853   Dali::BaseHandle arg1 ;
62854   Dali::BaseHandle *argp1 ;
62855   Dali::Toolkit::TransitionData result;
62856
62857   argp1 = (Dali::BaseHandle *)jarg1;
62858   if (!argp1) {
62859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62860     return 0;
62861   }
62862   arg1 = *argp1;
62863   {
62864     try {
62865       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62866     } catch (std::out_of_range& e) {
62867       {
62868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62869       };
62870     } catch (std::exception& e) {
62871       {
62872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62873       };
62874     } catch (Dali::DaliException e) {
62875       {
62876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62877       };
62878     } catch (...) {
62879       {
62880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62881       };
62882     }
62883   }
62884
62885   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62886   return jresult;
62887 }
62888
62889
62890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62891   void * jresult ;
62892   Dali::Toolkit::TransitionData *arg1 = 0 ;
62893   Dali::Toolkit::TransitionData *result = 0 ;
62894
62895   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62896   if (!arg1) {
62897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62898     return 0;
62899   }
62900   {
62901     try {
62902       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62903     } catch (std::out_of_range& e) {
62904       {
62905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62906       };
62907     } catch (std::exception& e) {
62908       {
62909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62910       };
62911     } catch (Dali::DaliException e) {
62912       {
62913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62914       };
62915     } catch (...) {
62916       {
62917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62918       };
62919     }
62920   }
62921
62922   jresult = (void *)result;
62923   return jresult;
62924 }
62925
62926
62927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62928   void * jresult ;
62929   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62930   Dali::Toolkit::TransitionData *arg2 = 0 ;
62931   Dali::Toolkit::TransitionData *result = 0 ;
62932
62933   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62934   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62935   if (!arg2) {
62936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62937     return 0;
62938   }
62939   {
62940     try {
62941       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62942     } catch (std::out_of_range& e) {
62943       {
62944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62945       };
62946     } catch (std::exception& e) {
62947       {
62948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62949       };
62950     } catch (Dali::DaliException e) {
62951       {
62952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62953       };
62954     } catch (...) {
62955       {
62956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62957       };
62958     }
62959   }
62960
62961   jresult = (void *)result;
62962   return jresult;
62963 }
62964
62965
62966 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62967   unsigned long jresult ;
62968   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62969   size_t result;
62970
62971   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62972   {
62973     try {
62974       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62975     } catch (std::out_of_range& e) {
62976       {
62977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62978       };
62979     } catch (std::exception& e) {
62980       {
62981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62982       };
62983     } catch (Dali::DaliException e) {
62984       {
62985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62986       };
62987     } catch (...) {
62988       {
62989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62990       };
62991     }
62992   }
62993
62994   jresult = (unsigned long)result;
62995   return jresult;
62996 }
62997
62998
62999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
63000   void * jresult ;
63001   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
63002   size_t arg2 ;
63003   Dali::Property::Map result;
63004
63005   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
63006   arg2 = (size_t)jarg2;
63007   {
63008     try {
63009       result = (arg1)->GetAnimatorAt(arg2);
63010     } catch (std::out_of_range& e) {
63011       {
63012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63013       };
63014     } catch (std::exception& e) {
63015       {
63016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63017       };
63018     } catch (Dali::DaliException e) {
63019       {
63020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63021       };
63022     } catch (...) {
63023       {
63024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63025       };
63026     }
63027   }
63028
63029   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
63030   return jresult;
63031 }
63032
63033
63034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
63035   int jresult ;
63036   int result;
63037
63038   {
63039     try {
63040       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
63041     } catch (std::out_of_range& e) {
63042       {
63043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63044       };
63045     } catch (std::exception& e) {
63046       {
63047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63048       };
63049     } catch (Dali::DaliException e) {
63050       {
63051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63052       };
63053     } catch (...) {
63054       {
63055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63056       };
63057     }
63058   }
63059
63060   jresult = (int)result;
63061   return jresult;
63062 }
63063
63064
63065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
63066   int jresult ;
63067   int result;
63068
63069   {
63070     try {
63071       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63072     } catch (std::out_of_range& e) {
63073       {
63074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63075       };
63076     } catch (std::exception& e) {
63077       {
63078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63079       };
63080     } catch (Dali::DaliException e) {
63081       {
63082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63083       };
63084     } catch (...) {
63085       {
63086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63087       };
63088     }
63089   }
63090
63091   jresult = (int)result;
63092   return jresult;
63093 }
63094
63095
63096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63097   int jresult ;
63098   int result;
63099
63100   {
63101     try {
63102       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63103     } catch (std::out_of_range& e) {
63104       {
63105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63106       };
63107     } catch (std::exception& e) {
63108       {
63109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63110       };
63111     } catch (Dali::DaliException e) {
63112       {
63113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63114       };
63115     } catch (...) {
63116       {
63117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63118       };
63119     }
63120   }
63121
63122   jresult = (int)result;
63123   return jresult;
63124 }
63125
63126
63127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63128   int jresult ;
63129   int result;
63130
63131   {
63132     try {
63133       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63134     } catch (std::out_of_range& e) {
63135       {
63136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63137       };
63138     } catch (std::exception& e) {
63139       {
63140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63141       };
63142     } catch (Dali::DaliException e) {
63143       {
63144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63145       };
63146     } catch (...) {
63147       {
63148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63149       };
63150     }
63151   }
63152
63153   jresult = (int)result;
63154   return jresult;
63155 }
63156
63157
63158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63159   int jresult ;
63160   int result;
63161
63162   {
63163     try {
63164       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63165     } catch (std::out_of_range& e) {
63166       {
63167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63168       };
63169     } catch (std::exception& e) {
63170       {
63171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63172       };
63173     } catch (Dali::DaliException e) {
63174       {
63175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63176       };
63177     } catch (...) {
63178       {
63179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63180       };
63181     }
63182   }
63183
63184   jresult = (int)result;
63185   return jresult;
63186 }
63187
63188
63189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63190   int jresult ;
63191   int result;
63192
63193   {
63194     try {
63195       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63196     } catch (std::out_of_range& e) {
63197       {
63198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63199       };
63200     } catch (std::exception& e) {
63201       {
63202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63203       };
63204     } catch (Dali::DaliException e) {
63205       {
63206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63207       };
63208     } catch (...) {
63209       {
63210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63211       };
63212     }
63213   }
63214
63215   jresult = (int)result;
63216   return jresult;
63217 }
63218
63219
63220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63221   int jresult ;
63222   int result;
63223
63224   {
63225     try {
63226       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63227     } catch (std::out_of_range& e) {
63228       {
63229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63230       };
63231     } catch (std::exception& e) {
63232       {
63233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63234       };
63235     } catch (Dali::DaliException e) {
63236       {
63237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63238       };
63239     } catch (...) {
63240       {
63241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63242       };
63243     }
63244   }
63245
63246   jresult = (int)result;
63247   return jresult;
63248 }
63249
63250
63251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63252   int jresult ;
63253   int result;
63254
63255   {
63256     try {
63257       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63258     } catch (std::out_of_range& e) {
63259       {
63260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63261       };
63262     } catch (std::exception& e) {
63263       {
63264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63265       };
63266     } catch (Dali::DaliException e) {
63267       {
63268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63269       };
63270     } catch (...) {
63271       {
63272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63273       };
63274     }
63275   }
63276
63277   jresult = (int)result;
63278   return jresult;
63279 }
63280
63281
63282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63283   int jresult ;
63284   int result;
63285
63286   {
63287     try {
63288       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63289     } catch (std::out_of_range& e) {
63290       {
63291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63292       };
63293     } catch (std::exception& e) {
63294       {
63295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63296       };
63297     } catch (Dali::DaliException e) {
63298       {
63299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63300       };
63301     } catch (...) {
63302       {
63303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63304       };
63305     }
63306   }
63307
63308   jresult = (int)result;
63309   return jresult;
63310 }
63311
63312
63313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63314   int jresult ;
63315   int result;
63316
63317   {
63318     try {
63319       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63320     } catch (std::out_of_range& e) {
63321       {
63322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63323       };
63324     } catch (std::exception& e) {
63325       {
63326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63327       };
63328     } catch (Dali::DaliException e) {
63329       {
63330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63331       };
63332     } catch (...) {
63333       {
63334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63335       };
63336     }
63337   }
63338
63339   jresult = (int)result;
63340   return jresult;
63341 }
63342
63343
63344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63345   int jresult ;
63346   int result;
63347
63348   {
63349     try {
63350       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63351     } catch (std::out_of_range& e) {
63352       {
63353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63354       };
63355     } catch (std::exception& e) {
63356       {
63357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63358       };
63359     } catch (Dali::DaliException e) {
63360       {
63361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63362       };
63363     } catch (...) {
63364       {
63365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63366       };
63367     }
63368   }
63369
63370   jresult = (int)result;
63371   return jresult;
63372 }
63373
63374
63375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63376   int jresult ;
63377   int result;
63378
63379   {
63380     try {
63381       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63382     } catch (std::out_of_range& e) {
63383       {
63384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63385       };
63386     } catch (std::exception& e) {
63387       {
63388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63389       };
63390     } catch (Dali::DaliException e) {
63391       {
63392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63393       };
63394     } catch (...) {
63395       {
63396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63397       };
63398     }
63399   }
63400
63401   jresult = (int)result;
63402   return jresult;
63403 }
63404
63405
63406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63407   int jresult ;
63408   int result;
63409
63410   {
63411     try {
63412       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63413     } catch (std::out_of_range& e) {
63414       {
63415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63416       };
63417     } catch (std::exception& e) {
63418       {
63419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63420       };
63421     } catch (Dali::DaliException e) {
63422       {
63423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63424       };
63425     } catch (...) {
63426       {
63427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63428       };
63429     }
63430   }
63431
63432   jresult = (int)result;
63433   return jresult;
63434 }
63435
63436
63437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63438   int jresult ;
63439   int result;
63440
63441   {
63442     try {
63443       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63444     } catch (std::out_of_range& e) {
63445       {
63446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63447       };
63448     } catch (std::exception& e) {
63449       {
63450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63451       };
63452     } catch (Dali::DaliException e) {
63453       {
63454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63455       };
63456     } catch (...) {
63457       {
63458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63459       };
63460     }
63461   }
63462
63463   jresult = (int)result;
63464   return jresult;
63465 }
63466
63467
63468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63469   void * jresult ;
63470   Dali::Toolkit::Control result;
63471
63472   {
63473     try {
63474       result = Dali::Toolkit::Internal::Control::New();
63475     } catch (std::out_of_range& e) {
63476       {
63477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63478       };
63479     } catch (std::exception& e) {
63480       {
63481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63482       };
63483     } catch (Dali::DaliException e) {
63484       {
63485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63486       };
63487     } catch (...) {
63488       {
63489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63490       };
63491     }
63492   }
63493
63494   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63495   return jresult;
63496 }
63497
63498
63499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63501   std::string *arg2 = 0 ;
63502
63503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63504   if (!jarg2) {
63505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63506     return ;
63507   }
63508   std::string arg2_str(jarg2);
63509   arg2 = &arg2_str;
63510   {
63511     try {
63512       (arg1)->SetStyleName((std::string const &)*arg2);
63513     } catch (std::out_of_range& e) {
63514       {
63515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63516       };
63517     } catch (std::exception& e) {
63518       {
63519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63520       };
63521     } catch (Dali::DaliException e) {
63522       {
63523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63524       };
63525     } catch (...) {
63526       {
63527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63528       };
63529     }
63530   }
63531
63532
63533   //argout typemap for const std::string&
63534
63535 }
63536
63537
63538 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63539   char * jresult ;
63540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63541   std::string *result = 0 ;
63542
63543   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63544   {
63545     try {
63546       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63547     } catch (std::out_of_range& e) {
63548       {
63549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63550       };
63551     } catch (std::exception& e) {
63552       {
63553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63554       };
63555     } catch (Dali::DaliException e) {
63556       {
63557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63558       };
63559     } catch (...) {
63560       {
63561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63562       };
63563     }
63564   }
63565
63566   jresult = SWIG_csharp_string_callback(result->c_str());
63567   return jresult;
63568 }
63569
63570
63571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63573   Dali::Vector4 *arg2 = 0 ;
63574
63575   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63576   arg2 = (Dali::Vector4 *)jarg2;
63577   if (!arg2) {
63578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63579     return ;
63580   }
63581   {
63582     try {
63583       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63584     } catch (std::out_of_range& e) {
63585       {
63586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63587       };
63588     } catch (std::exception& e) {
63589       {
63590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63591       };
63592     } catch (Dali::DaliException e) {
63593       {
63594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63595       };
63596     } catch (...) {
63597       {
63598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63599       };
63600     }
63601   }
63602
63603 }
63604
63605
63606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63607   void * jresult ;
63608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63609   Dali::Vector4 result;
63610
63611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63612   {
63613     try {
63614       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63615     } catch (std::out_of_range& e) {
63616       {
63617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63618       };
63619     } catch (std::exception& e) {
63620       {
63621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63622       };
63623     } catch (Dali::DaliException e) {
63624       {
63625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63626       };
63627     } catch (...) {
63628       {
63629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63630       };
63631     }
63632   }
63633
63634   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63635   return jresult;
63636 }
63637
63638
63639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63641   Dali::Image arg2 ;
63642   Dali::Image *argp2 ;
63643
63644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63645   argp2 = (Dali::Image *)jarg2;
63646   if (!argp2) {
63647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63648     return ;
63649   }
63650   arg2 = *argp2;
63651   {
63652     try {
63653       (arg1)->SetBackgroundImage(arg2);
63654     } catch (std::out_of_range& e) {
63655       {
63656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63657       };
63658     } catch (std::exception& e) {
63659       {
63660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63661       };
63662     } catch (Dali::DaliException e) {
63663       {
63664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63665       };
63666     } catch (...) {
63667       {
63668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63669       };
63670     }
63671   }
63672
63673 }
63674
63675
63676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63678   Dali::Property::Map *arg2 = 0 ;
63679
63680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63681   arg2 = (Dali::Property::Map *)jarg2;
63682   if (!arg2) {
63683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63684     return ;
63685   }
63686   {
63687     try {
63688       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63689     } catch (std::out_of_range& e) {
63690       {
63691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63692       };
63693     } catch (std::exception& e) {
63694       {
63695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63696       };
63697     } catch (Dali::DaliException e) {
63698       {
63699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63700       };
63701     } catch (...) {
63702       {
63703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63704       };
63705     }
63706   }
63707
63708 }
63709
63710
63711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63713
63714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63715   {
63716     try {
63717       (arg1)->ClearBackground();
63718     } catch (std::out_of_range& e) {
63719       {
63720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63721       };
63722     } catch (std::exception& e) {
63723       {
63724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63725       };
63726     } catch (Dali::DaliException e) {
63727       {
63728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63729       };
63730     } catch (...) {
63731       {
63732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63733       };
63734     }
63735   }
63736
63737 }
63738
63739
63740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63741   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63742   Dali::Gesture::Type arg2 ;
63743
63744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63745   arg2 = (Dali::Gesture::Type)jarg2;
63746   {
63747     try {
63748       (arg1)->EnableGestureDetection(arg2);
63749     } catch (std::out_of_range& e) {
63750       {
63751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63752       };
63753     } catch (std::exception& e) {
63754       {
63755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63756       };
63757     } catch (Dali::DaliException e) {
63758       {
63759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63760       };
63761     } catch (...) {
63762       {
63763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63764       };
63765     }
63766   }
63767
63768 }
63769
63770
63771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63773   Dali::Gesture::Type arg2 ;
63774
63775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63776   arg2 = (Dali::Gesture::Type)jarg2;
63777   {
63778     try {
63779       (arg1)->DisableGestureDetection(arg2);
63780     } catch (std::out_of_range& e) {
63781       {
63782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63783       };
63784     } catch (std::exception& e) {
63785       {
63786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63787       };
63788     } catch (Dali::DaliException e) {
63789       {
63790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63791       };
63792     } catch (...) {
63793       {
63794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63795       };
63796     }
63797   }
63798
63799 }
63800
63801
63802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63803   void * jresult ;
63804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63805   Dali::PinchGestureDetector result;
63806
63807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63808   {
63809     try {
63810       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63811     } catch (std::out_of_range& e) {
63812       {
63813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63814       };
63815     } catch (std::exception& e) {
63816       {
63817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63818       };
63819     } catch (Dali::DaliException e) {
63820       {
63821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63822       };
63823     } catch (...) {
63824       {
63825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63826       };
63827     }
63828   }
63829
63830   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63831   return jresult;
63832 }
63833
63834
63835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63836   void * jresult ;
63837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63838   Dali::PanGestureDetector result;
63839
63840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63841   {
63842     try {
63843       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63844     } catch (std::out_of_range& e) {
63845       {
63846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63847       };
63848     } catch (std::exception& e) {
63849       {
63850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63851       };
63852     } catch (Dali::DaliException e) {
63853       {
63854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63855       };
63856     } catch (...) {
63857       {
63858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63859       };
63860     }
63861   }
63862
63863   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63864   return jresult;
63865 }
63866
63867
63868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63869   void * jresult ;
63870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63871   Dali::TapGestureDetector result;
63872
63873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63874   {
63875     try {
63876       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63877     } catch (std::out_of_range& e) {
63878       {
63879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63880       };
63881     } catch (std::exception& e) {
63882       {
63883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63884       };
63885     } catch (Dali::DaliException e) {
63886       {
63887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63888       };
63889     } catch (...) {
63890       {
63891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63892       };
63893     }
63894   }
63895
63896   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63897   return jresult;
63898 }
63899
63900
63901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63902   void * jresult ;
63903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63904   Dali::LongPressGestureDetector result;
63905
63906   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63907   {
63908     try {
63909       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63910     } catch (std::out_of_range& e) {
63911       {
63912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63913       };
63914     } catch (std::exception& e) {
63915       {
63916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63917       };
63918     } catch (Dali::DaliException e) {
63919       {
63920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63921       };
63922     } catch (...) {
63923       {
63924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63925       };
63926     }
63927   }
63928
63929   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63930   return jresult;
63931 }
63932
63933
63934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63936   bool arg2 ;
63937
63938   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63939   arg2 = jarg2 ? true : false;
63940   {
63941     try {
63942       (arg1)->SetKeyboardNavigationSupport(arg2);
63943     } catch (std::out_of_range& e) {
63944       {
63945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63946       };
63947     } catch (std::exception& e) {
63948       {
63949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63950       };
63951     } catch (Dali::DaliException e) {
63952       {
63953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63954       };
63955     } catch (...) {
63956       {
63957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63958       };
63959     }
63960   }
63961
63962 }
63963
63964
63965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63966   unsigned int jresult ;
63967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63968   bool result;
63969
63970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63971   {
63972     try {
63973       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63974     } catch (std::out_of_range& e) {
63975       {
63976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63977       };
63978     } catch (std::exception& e) {
63979       {
63980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63981       };
63982     } catch (Dali::DaliException e) {
63983       {
63984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63985       };
63986     } catch (...) {
63987       {
63988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63989       };
63990     }
63991   }
63992
63993   jresult = result;
63994   return jresult;
63995 }
63996
63997
63998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63999   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64000
64001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64002   {
64003     try {
64004       (arg1)->SetKeyInputFocus();
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64012       };
64013     } catch (Dali::DaliException e) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64016       };
64017     } catch (...) {
64018       {
64019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64020       };
64021     }
64022   }
64023
64024 }
64025
64026
64027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
64028   unsigned int jresult ;
64029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64030   bool result;
64031
64032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64033   {
64034     try {
64035       result = (bool)(arg1)->HasKeyInputFocus();
64036     } catch (std::out_of_range& e) {
64037       {
64038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64039       };
64040     } catch (std::exception& e) {
64041       {
64042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64043       };
64044     } catch (Dali::DaliException e) {
64045       {
64046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64047       };
64048     } catch (...) {
64049       {
64050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64051       };
64052     }
64053   }
64054
64055   jresult = result;
64056   return jresult;
64057 }
64058
64059
64060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
64061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64062
64063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64064   {
64065     try {
64066       (arg1)->ClearKeyInputFocus();
64067     } catch (std::out_of_range& e) {
64068       {
64069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64070       };
64071     } catch (std::exception& e) {
64072       {
64073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64074       };
64075     } catch (Dali::DaliException e) {
64076       {
64077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64078       };
64079     } catch (...) {
64080       {
64081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64082       };
64083     }
64084   }
64085
64086 }
64087
64088
64089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64091   bool arg2 ;
64092
64093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64094   arg2 = jarg2 ? true : false;
64095   {
64096     try {
64097       (arg1)->SetAsKeyboardFocusGroup(arg2);
64098     } catch (std::out_of_range& e) {
64099       {
64100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64101       };
64102     } catch (std::exception& e) {
64103       {
64104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64105       };
64106     } catch (Dali::DaliException e) {
64107       {
64108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64109       };
64110     } catch (...) {
64111       {
64112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64113       };
64114     }
64115   }
64116
64117 }
64118
64119
64120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64121   unsigned int jresult ;
64122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64123   bool result;
64124
64125   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64126   {
64127     try {
64128       result = (bool)(arg1)->IsKeyboardFocusGroup();
64129     } catch (std::out_of_range& e) {
64130       {
64131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64132       };
64133     } catch (std::exception& e) {
64134       {
64135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64136       };
64137     } catch (Dali::DaliException e) {
64138       {
64139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64140       };
64141     } catch (...) {
64142       {
64143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64144       };
64145     }
64146   }
64147
64148   jresult = result;
64149   return jresult;
64150 }
64151
64152
64153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64154   void * jresult ;
64155   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64156   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64157
64158   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64159   {
64160     try {
64161       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64162     } catch (std::out_of_range& e) {
64163       {
64164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64165       };
64166     } catch (std::exception& e) {
64167       {
64168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64169       };
64170     } catch (Dali::DaliException e) {
64171       {
64172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64173       };
64174     } catch (...) {
64175       {
64176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64177       };
64178     }
64179   }
64180
64181   jresult = (void *)result;
64182   return jresult;
64183 }
64184
64185
64186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64187   void * jresult ;
64188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64189   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64190
64191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64192   {
64193     try {
64194       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64195     } catch (std::out_of_range& e) {
64196       {
64197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64198       };
64199     } catch (std::exception& e) {
64200       {
64201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64202       };
64203     } catch (Dali::DaliException e) {
64204       {
64205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64206       };
64207     } catch (...) {
64208       {
64209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64210       };
64211     }
64212   }
64213
64214   jresult = (void *)result;
64215   return jresult;
64216 }
64217
64218
64219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64220   void * jresult ;
64221   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64222   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64223
64224   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64225   {
64226     try {
64227       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64228     } catch (std::out_of_range& e) {
64229       {
64230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64231       };
64232     } catch (std::exception& e) {
64233       {
64234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64235       };
64236     } catch (Dali::DaliException e) {
64237       {
64238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64239       };
64240     } catch (...) {
64241       {
64242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64243       };
64244     }
64245   }
64246
64247   jresult = (void *)result;
64248   return jresult;
64249 }
64250
64251
64252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64253   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64254   int arg2 ;
64255   SwigDirector_ViewImpl *darg = 0;
64256
64257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64258   arg2 = (int)jarg2;
64259   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64260   if(!darg) {
64261     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64262     return;
64263   }
64264   {
64265     try {
64266       if(darg) {
64267         (darg)->OnStageConnection(arg2);
64268       }
64269     } catch (std::out_of_range& e) {
64270       {
64271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64272       };
64273     } catch (std::exception& e) {
64274       {
64275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64276       };
64277     } catch (Dali::DaliException e) {
64278       {
64279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64280       };
64281     } catch (...) {
64282       {
64283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64284       };
64285     }
64286   }
64287
64288 }
64289
64290
64291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64293   int arg2 ;
64294   SwigDirector_ViewImpl *darg = 0;
64295
64296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64297   arg2 = (int)jarg2;
64298   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64299   if(!darg) {
64300     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64301     return;
64302   }
64303   {
64304     try {
64305       if(darg) {
64306         (darg)->OnStageConnectionSwigPublic(arg2);
64307       }
64308     } catch (std::out_of_range& e) {
64309       {
64310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64311       };
64312     } catch (std::exception& e) {
64313       {
64314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64315       };
64316     } catch (Dali::DaliException e) {
64317       {
64318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64319       };
64320     } catch (...) {
64321       {
64322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64323       };
64324     }
64325   }
64326
64327 }
64328
64329
64330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64332   SwigDirector_ViewImpl *darg = 0;
64333
64334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64335   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64336   if(!darg) {
64337     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64338     return;
64339   }
64340   {
64341     try {
64342       if(darg) {
64343         (darg)->OnStageDisconnection();
64344       }
64345     } catch (std::out_of_range& e) {
64346       {
64347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64348       };
64349     } catch (std::exception& e) {
64350       {
64351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64352       };
64353     } catch (Dali::DaliException e) {
64354       {
64355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64356       };
64357     } catch (...) {
64358       {
64359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64360       };
64361     }
64362   }
64363
64364 }
64365
64366
64367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64369   SwigDirector_ViewImpl *darg = 0;
64370
64371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64372   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64373   if(!darg) {
64374     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64375     return;
64376   }
64377   {
64378     try {
64379       if(darg) {
64380         (darg)->OnStageDisconnectionSwigPublic();
64381       }
64382     } catch (std::out_of_range& e) {
64383       {
64384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64385       };
64386     } catch (std::exception& e) {
64387       {
64388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64389       };
64390     } catch (Dali::DaliException e) {
64391       {
64392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64393       };
64394     } catch (...) {
64395       {
64396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64397       };
64398     }
64399   }
64400
64401 }
64402
64403
64404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64406   Dali::Actor *arg2 = 0 ;
64407   SwigDirector_ViewImpl *darg = 0;
64408
64409   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64410   arg2 = (Dali::Actor *)jarg2;
64411   if (!arg2) {
64412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64413     return ;
64414   }
64415   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64416   if(!darg) {
64417     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64418     return;
64419   }
64420   {
64421     try {
64422       if(darg) {
64423         (darg)->OnChildAdd(*arg2);
64424       }
64425     } catch (std::out_of_range& e) {
64426       {
64427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64428       };
64429     } catch (std::exception& e) {
64430       {
64431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64432       };
64433     } catch (Dali::DaliException e) {
64434       {
64435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64436       };
64437     } catch (...) {
64438       {
64439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64440       };
64441     }
64442   }
64443
64444 }
64445
64446
64447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64449   Dali::Actor *arg2 = 0 ;
64450   SwigDirector_ViewImpl *darg = 0;
64451
64452   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64453   arg2 = (Dali::Actor *)jarg2;
64454   if (!arg2) {
64455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64456     return ;
64457   }
64458   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64459   if(!darg) {
64460     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64461     return;
64462   }
64463   {
64464     try {
64465       if(darg) {
64466           (darg)->OnChildAddSwigPublic(*arg2);
64467       }
64468     } catch (std::out_of_range& e) {
64469       {
64470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64471       };
64472     } catch (std::exception& e) {
64473       {
64474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64475       };
64476     } catch (Dali::DaliException e) {
64477       {
64478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64479       };
64480     } catch (...) {
64481       {
64482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64483       };
64484     }
64485   }
64486
64487 }
64488
64489
64490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64491   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64492   Dali::Actor *arg2 = 0 ;
64493   SwigDirector_ViewImpl *darg = 0;
64494
64495   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64496   arg2 = (Dali::Actor *)jarg2;
64497   if (!arg2) {
64498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64499     return ;
64500   }
64501   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64502   if(!darg) {
64503     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64504     return;
64505   }
64506   {
64507     try {
64508       if(darg) {
64509         (darg)->OnChildRemove(*arg2);
64510       }
64511     } catch (std::out_of_range& e) {
64512       {
64513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64514       };
64515     } catch (std::exception& e) {
64516       {
64517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64518       };
64519     } catch (Dali::DaliException e) {
64520       {
64521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64522       };
64523     } catch (...) {
64524       {
64525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64526       };
64527     }
64528   }
64529
64530 }
64531
64532
64533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64535   Dali::Actor *arg2 = 0 ;
64536   SwigDirector_ViewImpl *darg = 0;
64537
64538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64539   arg2 = (Dali::Actor *)jarg2;
64540   if (!arg2) {
64541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64542     return ;
64543   }
64544   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64545   if(!darg) {
64546     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64547     return;
64548   }
64549   {
64550     try {
64551       if(darg) {
64552         (darg)->OnChildRemoveSwigPublic(*arg2);
64553       }
64554     } catch (std::out_of_range& e) {
64555       {
64556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64557       };
64558     } catch (std::exception& e) {
64559       {
64560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64561       };
64562     } catch (Dali::DaliException e) {
64563       {
64564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64565       };
64566     } catch (...) {
64567       {
64568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64569       };
64570     }
64571   }
64572
64573 }
64574
64575
64576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64578   Dali::Property::Index arg2 ;
64579   Dali::Property::Value arg3 ;
64580   Dali::Property::Value *argp3 ;
64581   SwigDirector_ViewImpl *darg = 0;
64582
64583   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64584   arg2 = (Dali::Property::Index)jarg2;
64585   argp3 = (Dali::Property::Value *)jarg3;
64586   if (!argp3) {
64587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64588     return ;
64589   }
64590   arg3 = *argp3;
64591   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64592   if (!darg) {
64593     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64594     return;
64595   }
64596   {
64597     try {
64598       (darg)->OnPropertySet(arg2,arg3);
64599     } catch (std::out_of_range& e) {
64600       {
64601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64602       };
64603     } catch (std::exception& e) {
64604       {
64605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64606       };
64607     } catch (Dali::DaliException e) {
64608       {
64609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64610       };
64611     } catch (...) {
64612       {
64613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64614       };
64615     }
64616   }
64617
64618 }
64619
64620
64621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64622   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64623   Dali::Property::Index arg2 ;
64624   Dali::Property::Value arg3 ;
64625   Dali::Property::Value *argp3 ;
64626   SwigDirector_ViewImpl *darg = 0;
64627
64628   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64629   arg2 = (Dali::Property::Index)jarg2;
64630   argp3 = (Dali::Property::Value *)jarg3;
64631   if (!argp3) {
64632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64633     return ;
64634   }
64635   arg3 = *argp3;
64636   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64637   if (!darg) {
64638     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64639     return;
64640   }
64641   {
64642     try {
64643       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64644     } catch (std::out_of_range& e) {
64645       {
64646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64647       };
64648     } catch (std::exception& e) {
64649       {
64650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64651       };
64652     } catch (Dali::DaliException e) {
64653       {
64654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64655       };
64656     } catch (...) {
64657       {
64658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64659       };
64660     }
64661   }
64662
64663 }
64664
64665
64666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64668   Dali::Vector3 *arg2 = 0 ;
64669   SwigDirector_ViewImpl *darg = 0;
64670
64671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64672   arg2 = (Dali::Vector3 *)jarg2;
64673   if (!arg2) {
64674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64675     return ;
64676   }
64677   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64678   if (!darg) {
64679     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64680     return;
64681   }
64682   {
64683     try {
64684       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64685     } catch (std::out_of_range& e) {
64686       {
64687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64688       };
64689     } catch (std::exception& e) {
64690       {
64691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64692       };
64693     } catch (Dali::DaliException e) {
64694       {
64695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64696       };
64697     } catch (...) {
64698       {
64699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64700       };
64701     }
64702   }
64703
64704 }
64705
64706
64707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64708   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64709   Dali::Vector3 *arg2 = 0 ;
64710   SwigDirector_ViewImpl *darg = 0;
64711
64712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64713   arg2 = (Dali::Vector3 *)jarg2;
64714   if (!arg2) {
64715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64716     return ;
64717   }
64718   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64719   if (!darg) {
64720     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64721     return;
64722   }
64723   {
64724     try {
64725       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64726     } catch (std::out_of_range& e) {
64727       {
64728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64729       };
64730     } catch (std::exception& e) {
64731       {
64732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64733       };
64734     } catch (Dali::DaliException e) {
64735       {
64736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64737       };
64738     } catch (...) {
64739       {
64740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64741       };
64742     }
64743   }
64744
64745 }
64746
64747
64748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64749   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64750   Dali::Animation *arg2 = 0 ;
64751   Dali::Vector3 *arg3 = 0 ;
64752   SwigDirector_ViewImpl *darg = 0;
64753
64754   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64755   arg2 = (Dali::Animation *)jarg2;
64756   if (!arg2) {
64757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64758     return ;
64759   }
64760   arg3 = (Dali::Vector3 *)jarg3;
64761   if (!arg3) {
64762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64763     return ;
64764   }
64765   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64766   if (!darg) {
64767     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64768     return;
64769   }
64770   {
64771     try {
64772       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64773     } catch (std::out_of_range& e) {
64774       {
64775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64776       };
64777     } catch (std::exception& e) {
64778       {
64779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64780       };
64781     } catch (Dali::DaliException e) {
64782       {
64783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64784       };
64785     } catch (...) {
64786       {
64787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64788       };
64789     }
64790   }
64791
64792 }
64793
64794
64795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64797   Dali::Animation *arg2 = 0 ;
64798   Dali::Vector3 *arg3 = 0 ;
64799   SwigDirector_ViewImpl *darg = 0;
64800
64801   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64802   arg2 = (Dali::Animation *)jarg2;
64803   if (!arg2) {
64804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64805     return ;
64806   }
64807   arg3 = (Dali::Vector3 *)jarg3;
64808   if (!arg3) {
64809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64810     return ;
64811   }
64812   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64813   if (!darg) {
64814     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64815     return;
64816   }
64817   {
64818     try {
64819       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64820     } catch (std::out_of_range& e) {
64821       {
64822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64823       };
64824     } catch (std::exception& e) {
64825       {
64826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64827       };
64828     } catch (Dali::DaliException e) {
64829       {
64830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64831       };
64832     } catch (...) {
64833       {
64834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64835       };
64836     }
64837   }
64838
64839 }
64840
64841
64842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64843   unsigned int jresult ;
64844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64845   Dali::TouchEvent *arg2 = 0 ;
64846   SwigDirector_ViewImpl *darg = 0;
64847   bool result;
64848
64849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64850   arg2 = (Dali::TouchEvent *)jarg2;
64851   if (!arg2) {
64852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64853     return 0;
64854   }
64855   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64856   if (!darg) {
64857     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64858     return 0;
64859   }
64860   {
64861     try {
64862       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64863     } catch (std::out_of_range& e) {
64864       {
64865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64866       };
64867     } catch (std::exception& e) {
64868       {
64869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64870       };
64871     } catch (Dali::DaliException e) {
64872       {
64873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64874       };
64875     } catch (...) {
64876       {
64877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64878       };
64879     }
64880   }
64881
64882   jresult = result;
64883   return jresult;
64884 }
64885
64886
64887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64888   unsigned int jresult ;
64889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64890   Dali::TouchEvent *arg2 = 0 ;
64891   SwigDirector_ViewImpl *darg = 0;
64892   bool result;
64893
64894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64895   arg2 = (Dali::TouchEvent *)jarg2;
64896   if (!arg2) {
64897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64898     return 0;
64899   }
64900   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64901   if (!darg) {
64902     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64903     return 0;
64904   }
64905   {
64906     try {
64907       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64908     } catch (std::out_of_range& e) {
64909       {
64910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64911       };
64912     } catch (std::exception& e) {
64913       {
64914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64915       };
64916     } catch (Dali::DaliException e) {
64917       {
64918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64919       };
64920     } catch (...) {
64921       {
64922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64923       };
64924     }
64925   }
64926
64927   jresult = result;
64928   return jresult;
64929 }
64930
64931
64932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64933   unsigned int jresult ;
64934   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64935   Dali::HoverEvent *arg2 = 0 ;
64936   SwigDirector_ViewImpl *darg = 0;
64937   bool result;
64938
64939   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64940   arg2 = (Dali::HoverEvent *)jarg2;
64941   if (!arg2) {
64942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64943     return 0;
64944   }
64945   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64946   if (!darg) {
64947     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64948     return 0;
64949   }
64950   {
64951     try {
64952       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64953     } catch (std::out_of_range& e) {
64954       {
64955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64956       };
64957     } catch (std::exception& e) {
64958       {
64959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64960       };
64961     } catch (Dali::DaliException e) {
64962       {
64963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64964       };
64965     } catch (...) {
64966       {
64967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64968       };
64969     }
64970   }
64971
64972   jresult = result;
64973   return jresult;
64974 }
64975
64976
64977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64978   unsigned int jresult ;
64979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64980   Dali::HoverEvent *arg2 = 0 ;
64981   SwigDirector_ViewImpl *darg = 0;
64982   bool result;
64983
64984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64985   arg2 = (Dali::HoverEvent *)jarg2;
64986   if (!arg2) {
64987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64988     return 0;
64989   }
64990   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64991   if (!darg) {
64992     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64993     return 0;
64994   }
64995   {
64996     try {
64997       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64998     } catch (std::out_of_range& e) {
64999       {
65000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65001       };
65002     } catch (std::exception& e) {
65003       {
65004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65005       };
65006     } catch (Dali::DaliException e) {
65007       {
65008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65009       };
65010     } catch (...) {
65011       {
65012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65013       };
65014     }
65015   }
65016
65017   jresult = result;
65018   return jresult;
65019 }
65020
65021
65022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
65023   unsigned int jresult ;
65024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65025   Dali::KeyEvent *arg2 = 0 ;
65026   SwigDirector_ViewImpl *darg = 0;
65027   bool result;
65028
65029   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65030   arg2 = (Dali::KeyEvent *)jarg2;
65031   if (!arg2) {
65032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65033     return 0;
65034   }
65035   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65036   if (!darg) {
65037     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65038     return 0;
65039   }
65040   {
65041     try {
65042       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65043     } catch (std::out_of_range& e) {
65044       {
65045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65046       };
65047     } catch (std::exception& e) {
65048       {
65049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65050       };
65051     } catch (Dali::DaliException e) {
65052       {
65053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65054       };
65055     } catch (...) {
65056       {
65057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65058       };
65059     }
65060   }
65061
65062   jresult = result;
65063   return jresult;
65064 }
65065
65066
65067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65068   unsigned int jresult ;
65069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65070   Dali::KeyEvent *arg2 = 0 ;
65071   SwigDirector_ViewImpl *darg = 0;
65072   bool result;
65073
65074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65075   arg2 = (Dali::KeyEvent *)jarg2;
65076   if (!arg2) {
65077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65078     return 0;
65079   }
65080   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65081   if (!darg) {
65082     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65083     return 0;
65084   }
65085   {
65086     try {
65087       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65088     } catch (std::out_of_range& e) {
65089       {
65090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65091       };
65092     } catch (std::exception& e) {
65093       {
65094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65095       };
65096     } catch (Dali::DaliException e) {
65097       {
65098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65099       };
65100     } catch (...) {
65101       {
65102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65103       };
65104     }
65105   }
65106
65107   jresult = result;
65108   return jresult;
65109 }
65110
65111
65112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65113   unsigned int jresult ;
65114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65115   Dali::WheelEvent *arg2 = 0 ;
65116   SwigDirector_ViewImpl *darg = 0;
65117   bool result;
65118
65119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65120   arg2 = (Dali::WheelEvent *)jarg2;
65121   if (!arg2) {
65122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65123     return 0;
65124   }
65125   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65126   if (!darg) {
65127     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65128     return 0;
65129   }
65130   {
65131     try {
65132       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65133     } catch (std::out_of_range& e) {
65134       {
65135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65136       };
65137     } catch (std::exception& e) {
65138       {
65139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65140       };
65141     } catch (Dali::DaliException e) {
65142       {
65143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65144       };
65145     } catch (...) {
65146       {
65147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65148       };
65149     }
65150   }
65151
65152   jresult = result;
65153   return jresult;
65154 }
65155
65156
65157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65158   unsigned int jresult ;
65159   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65160   Dali::WheelEvent *arg2 = 0 ;
65161   SwigDirector_ViewImpl *darg = 0;
65162   bool result;
65163
65164   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65165   arg2 = (Dali::WheelEvent *)jarg2;
65166   if (!arg2) {
65167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65168     return 0;
65169   }
65170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65171   if (!darg) {
65172     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65173     return 0;
65174   }
65175   {
65176     try {
65177       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65178     } catch (std::out_of_range& e) {
65179       {
65180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65181       };
65182     } catch (std::exception& e) {
65183       {
65184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65185       };
65186     } catch (Dali::DaliException e) {
65187       {
65188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65189       };
65190     } catch (...) {
65191       {
65192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65193       };
65194     }
65195   }
65196
65197   jresult = result;
65198   return jresult;
65199 }
65200
65201
65202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65204   Dali::Vector2 *arg2 = 0 ;
65205   Dali::RelayoutContainer *arg3 = 0 ;
65206   SwigDirector_ViewImpl *darg = 0;
65207
65208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65209   arg2 = (Dali::Vector2 *)jarg2;
65210   if (!arg2) {
65211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65212     return ;
65213   }
65214   arg3 = (Dali::RelayoutContainer *)jarg3;
65215   if (!arg3) {
65216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65217     return ;
65218   }
65219   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65220   if (!darg) {
65221     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65222     return;
65223   }
65224   {
65225     try {
65226       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65227     } catch (std::out_of_range& e) {
65228       {
65229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65230       };
65231     } catch (std::exception& e) {
65232       {
65233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65234       };
65235     } catch (Dali::DaliException e) {
65236       {
65237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65238       };
65239     } catch (...) {
65240       {
65241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65242       };
65243     }
65244   }
65245
65246 }
65247
65248
65249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65250   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65251   Dali::Vector2 *arg2 = 0 ;
65252   Dali::RelayoutContainer *arg3 = 0 ;
65253   SwigDirector_ViewImpl *darg = 0;
65254
65255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65256   arg2 = (Dali::Vector2 *)jarg2;
65257   if (!arg2) {
65258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65259     return ;
65260   }
65261   arg3 = (Dali::RelayoutContainer *)jarg3;
65262   if (!arg3) {
65263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65264     return ;
65265   }
65266   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65267   if (!darg) {
65268     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65269     return;
65270   }
65271   {
65272     try {
65273       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65274     } catch (std::out_of_range& e) {
65275       {
65276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65277       };
65278     } catch (std::exception& e) {
65279       {
65280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65281       };
65282     } catch (Dali::DaliException e) {
65283       {
65284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65285       };
65286     } catch (...) {
65287       {
65288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65289       };
65290     }
65291   }
65292
65293 }
65294
65295
65296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65297   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65298   Dali::ResizePolicy::Type arg2 ;
65299   Dali::Dimension::Type arg3 ;
65300   SwigDirector_ViewImpl *darg = 0;
65301
65302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65303   arg2 = (Dali::ResizePolicy::Type)jarg2;
65304   arg3 = (Dali::Dimension::Type)jarg3;
65305   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65306   if (!darg) {
65307     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65308     return;
65309   }
65310   {
65311     try {
65312       (darg)->OnSetResizePolicy(arg2,arg3);
65313     } catch (std::out_of_range& e) {
65314       {
65315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65316       };
65317     } catch (std::exception& e) {
65318       {
65319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65320       };
65321     } catch (Dali::DaliException e) {
65322       {
65323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65324       };
65325     } catch (...) {
65326       {
65327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65328       };
65329     }
65330   }
65331
65332 }
65333
65334
65335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65337   Dali::ResizePolicy::Type arg2 ;
65338   Dali::Dimension::Type arg3 ;
65339   SwigDirector_ViewImpl *darg = 0;
65340
65341   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65342   arg2 = (Dali::ResizePolicy::Type)jarg2;
65343   arg3 = (Dali::Dimension::Type)jarg3;
65344   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65345   if (!darg) {
65346     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65347     return;
65348   }
65349   {
65350     try {
65351       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65352     } catch (std::out_of_range& e) {
65353       {
65354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65355       };
65356     } catch (std::exception& e) {
65357       {
65358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65359       };
65360     } catch (Dali::DaliException e) {
65361       {
65362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65363       };
65364     } catch (...) {
65365       {
65366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65367       };
65368     }
65369   }
65370
65371 }
65372
65373
65374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65375   void * jresult ;
65376   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65377   SwigDirector_ViewImpl *darg = 0;
65378   Dali::Vector3 result;
65379
65380   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65381   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65382   if (!darg) {
65383     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65384     return 0;
65385   }
65386   {
65387     try {
65388       result = (darg)->GetNaturalSize();
65389     } catch (std::out_of_range& e) {
65390       {
65391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65392       };
65393     } catch (std::exception& e) {
65394       {
65395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65396       };
65397     } catch (Dali::DaliException e) {
65398       {
65399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65400       };
65401     } catch (...) {
65402       {
65403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65404       };
65405     }
65406   }
65407
65408   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65409   return jresult;
65410 }
65411
65412
65413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65414   void * jresult ;
65415   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65416   SwigDirector_ViewImpl *darg = 0;
65417   Dali::Vector3 result;
65418
65419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65420   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65421   if (!darg) {
65422     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65423     return 0;
65424   }
65425   {
65426     try {
65427       result = (darg)->GetNaturalSizeSwigPublic();
65428     } catch (std::out_of_range& e) {
65429       {
65430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65431       };
65432     } catch (std::exception& e) {
65433       {
65434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65435       };
65436     } catch (Dali::DaliException e) {
65437       {
65438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65439       };
65440     } catch (...) {
65441       {
65442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65443       };
65444     }
65445   }
65446
65447   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65448   return jresult;
65449 }
65450
65451
65452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65453   float jresult ;
65454   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65455   Dali::Actor *arg2 = 0 ;
65456   Dali::Dimension::Type arg3 ;
65457   SwigDirector_ViewImpl *darg = 0;
65458   float result;
65459
65460   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65461   arg2 = (Dali::Actor *)jarg2;
65462   if (!arg2) {
65463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65464     return 0;
65465   }
65466   arg3 = (Dali::Dimension::Type)jarg3;
65467   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65468   if (!darg) {
65469     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65470     return 0;
65471   }
65472   {
65473     try {
65474       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65475     } catch (std::out_of_range& e) {
65476       {
65477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65478       };
65479     } catch (std::exception& e) {
65480       {
65481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65482       };
65483     } catch (Dali::DaliException e) {
65484       {
65485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65486       };
65487     } catch (...) {
65488       {
65489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65490       };
65491     }
65492   }
65493
65494   jresult = result;
65495   return jresult;
65496 }
65497
65498
65499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65500   float jresult ;
65501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65502   Dali::Actor *arg2 = 0 ;
65503   Dali::Dimension::Type arg3 ;
65504   SwigDirector_ViewImpl *darg = 0;
65505   float result;
65506
65507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65508   arg2 = (Dali::Actor *)jarg2;
65509   if (!arg2) {
65510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65511     return 0;
65512   }
65513   arg3 = (Dali::Dimension::Type)jarg3;
65514   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65515   if (!darg) {
65516     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65517     return 0;
65518   }
65519   {
65520     try {
65521       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65522     } catch (std::out_of_range& e) {
65523       {
65524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65525       };
65526     } catch (std::exception& e) {
65527       {
65528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65529       };
65530     } catch (Dali::DaliException e) {
65531       {
65532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65533       };
65534     } catch (...) {
65535       {
65536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65537       };
65538     }
65539   }
65540
65541   jresult = result;
65542   return jresult;
65543 }
65544
65545
65546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65547   float jresult ;
65548   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65549   float arg2 ;
65550   SwigDirector_ViewImpl *darg = 0;
65551   float result;
65552
65553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65554   arg2 = (float)jarg2;
65555   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65556   if (!darg) {
65557     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65558     return 0;
65559   }
65560   {
65561     try {
65562       result = (float)(darg)->GetHeightForWidth(arg2);
65563     } catch (std::out_of_range& e) {
65564       {
65565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65566       };
65567     } catch (std::exception& e) {
65568       {
65569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65570       };
65571     } catch (Dali::DaliException e) {
65572       {
65573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65574       };
65575     } catch (...) {
65576       {
65577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65578       };
65579     }
65580   }
65581
65582   jresult = result;
65583   return jresult;
65584 }
65585
65586
65587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65588   float jresult ;
65589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65590   float arg2 ;
65591   SwigDirector_ViewImpl *darg = 0;
65592   float result;
65593
65594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65595   arg2 = (float)jarg2;
65596   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65597   if (!darg) {
65598     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65599     return 0;
65600   }
65601   {
65602     try {
65603       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65604     } catch (std::out_of_range& e) {
65605       {
65606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65607       };
65608     } catch (std::exception& e) {
65609       {
65610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65611       };
65612     } catch (Dali::DaliException e) {
65613       {
65614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65615       };
65616     } catch (...) {
65617       {
65618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65619       };
65620     }
65621   }
65622
65623   jresult = result;
65624   return jresult;
65625 }
65626
65627
65628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65629   float jresult ;
65630   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65631   float arg2 ;
65632   SwigDirector_ViewImpl *darg = 0;
65633   float result;
65634
65635   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65636   arg2 = (float)jarg2;
65637   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65638   if (!darg) {
65639     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65640     return 0;
65641   }
65642   {
65643     try {
65644       result = (float)(darg)->GetWidthForHeight(arg2);
65645     } catch (std::out_of_range& e) {
65646       {
65647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65648       };
65649     } catch (std::exception& e) {
65650       {
65651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65652       };
65653     } catch (Dali::DaliException e) {
65654       {
65655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65656       };
65657     } catch (...) {
65658       {
65659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65660       };
65661     }
65662   }
65663
65664   jresult = result;
65665   return jresult;
65666 }
65667
65668
65669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65670   float jresult ;
65671   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65672   float arg2 ;
65673   SwigDirector_ViewImpl *darg = 0;
65674   float result;
65675
65676   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65677   arg2 = (float)jarg2;
65678   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65679   if (!darg) {
65680     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65681     return 0;
65682   }
65683   {
65684     try {
65685       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65686     } catch (std::out_of_range& e) {
65687       {
65688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65689       };
65690     } catch (std::exception& e) {
65691       {
65692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65693       };
65694     } catch (Dali::DaliException e) {
65695       {
65696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65697       };
65698     } catch (...) {
65699       {
65700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65701       };
65702     }
65703   }
65704
65705   jresult = result;
65706   return jresult;
65707 }
65708
65709
65710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65711   unsigned int jresult ;
65712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65713   Dali::Dimension::Type arg2 ;
65714   SwigDirector_ViewImpl *darg = 0;
65715   bool result;
65716
65717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65718   arg2 = (Dali::Dimension::Type)jarg2;
65719   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65720   if (!darg) {
65721     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65722     return 0;
65723   }
65724   {
65725     try {
65726       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65727     } catch (std::out_of_range& e) {
65728       {
65729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65730       };
65731     } catch (std::exception& e) {
65732       {
65733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65734       };
65735     } catch (Dali::DaliException e) {
65736       {
65737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65738       };
65739     } catch (...) {
65740       {
65741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65742       };
65743     }
65744   }
65745
65746   jresult = result;
65747   return jresult;
65748 }
65749
65750
65751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65752   unsigned int jresult ;
65753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65754   Dali::Dimension::Type arg2 ;
65755   SwigDirector_ViewImpl *darg = 0;
65756   bool result;
65757
65758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65759   arg2 = (Dali::Dimension::Type)jarg2;
65760   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65761   if (!darg) {
65762     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65763     return 0;
65764   }
65765   {
65766     try {
65767       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65768     } catch (std::out_of_range& e) {
65769       {
65770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65771       };
65772     } catch (std::exception& e) {
65773       {
65774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65775       };
65776     } catch (Dali::DaliException e) {
65777       {
65778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65779       };
65780     } catch (...) {
65781       {
65782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65783       };
65784     }
65785   }
65786
65787   jresult = result;
65788   return jresult;
65789 }
65790
65791
65792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65793   unsigned int jresult ;
65794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65795   SwigDirector_ViewImpl *darg = 0;
65796   bool result;
65797
65798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65799   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65800   if (!darg) {
65801     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65802     return 0;
65803   }
65804   {
65805     try {
65806       result = (bool)(darg)->RelayoutDependentOnChildren();
65807     } catch (std::out_of_range& e) {
65808       {
65809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65810       };
65811     } catch (std::exception& e) {
65812       {
65813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65814       };
65815     } catch (Dali::DaliException e) {
65816       {
65817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65818       };
65819     } catch (...) {
65820       {
65821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65822       };
65823     }
65824   }
65825
65826   jresult = result;
65827   return jresult;
65828 }
65829
65830
65831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65832   unsigned int jresult ;
65833   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65834   SwigDirector_ViewImpl *darg = 0;
65835   bool result;
65836
65837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65838   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65839   if (!darg) {
65840     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65841     return 0;
65842   }
65843   {
65844     try {
65845       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65846     } catch (std::out_of_range& e) {
65847       {
65848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (std::exception& e) {
65851       {
65852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65853       };
65854     } catch (Dali::DaliException e) {
65855       {
65856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65857       };
65858     } catch (...) {
65859       {
65860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65861       };
65862     }
65863   }
65864
65865   jresult = result;
65866   return jresult;
65867 }
65868
65869
65870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65872   Dali::Dimension::Type arg2 ;
65873   SwigDirector_ViewImpl *darg = 0;
65874
65875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65876   arg2 = (Dali::Dimension::Type)jarg2;
65877   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65878   if (!darg) {
65879     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65880     return;
65881   }
65882   {
65883     try {
65884       (darg)->OnCalculateRelayoutSize(arg2);
65885     } catch (std::out_of_range& e) {
65886       {
65887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65888       };
65889     } catch (std::exception& e) {
65890       {
65891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65892       };
65893     } catch (Dali::DaliException e) {
65894       {
65895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65896       };
65897     } catch (...) {
65898       {
65899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65900       };
65901     }
65902   }
65903
65904 }
65905
65906
65907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65908   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65909   Dali::Dimension::Type arg2 ;
65910   SwigDirector_ViewImpl *darg = 0;
65911
65912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65913   arg2 = (Dali::Dimension::Type)jarg2;
65914   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65915   if (!darg) {
65916     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65917     return;
65918   }
65919   {
65920     try {
65921       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65922     } catch (std::out_of_range& e) {
65923       {
65924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65925       };
65926     } catch (std::exception& e) {
65927       {
65928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65929       };
65930     } catch (Dali::DaliException e) {
65931       {
65932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65933       };
65934     } catch (...) {
65935       {
65936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65937       };
65938     }
65939   }
65940
65941 }
65942
65943
65944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65946   float arg2 ;
65947   Dali::Dimension::Type arg3 ;
65948   SwigDirector_ViewImpl *darg = 0;
65949
65950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65951   arg2 = (float)jarg2;
65952   arg3 = (Dali::Dimension::Type)jarg3;
65953   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65954   if (!darg) {
65955     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65956     return;
65957   }
65958   {
65959     try {
65960       (darg)->OnLayoutNegotiated(arg2,arg3);
65961     } catch (std::out_of_range& e) {
65962       {
65963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65964       };
65965     } catch (std::exception& e) {
65966       {
65967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65968       };
65969     } catch (Dali::DaliException e) {
65970       {
65971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65972       };
65973     } catch (...) {
65974       {
65975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65976       };
65977     }
65978   }
65979
65980 }
65981
65982
65983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65984   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65985   float arg2 ;
65986   Dali::Dimension::Type arg3 ;
65987   SwigDirector_ViewImpl *darg = 0;
65988
65989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65990   arg2 = (float)jarg2;
65991   arg3 = (Dali::Dimension::Type)jarg3;
65992   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65993   if (!darg) {
65994     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65995     return;
65996   }
65997   {
65998     try {
65999       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
66000     } catch (std::out_of_range& e) {
66001       {
66002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66003       };
66004     } catch (std::exception& e) {
66005       {
66006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66007       };
66008     } catch (Dali::DaliException e) {
66009       {
66010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66011       };
66012     } catch (...) {
66013       {
66014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66015       };
66016     }
66017   }
66018
66019 }
66020
66021
66022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
66023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66024
66025   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66026   {
66027     try {
66028       (arg1)->OnInitialize();
66029     } catch (std::out_of_range& e) {
66030       {
66031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66032       };
66033     } catch (std::exception& e) {
66034       {
66035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66036       };
66037     } catch (Dali::DaliException e) {
66038       {
66039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66040       };
66041     } catch (...) {
66042       {
66043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66044       };
66045     }
66046   }
66047
66048 }
66049
66050
66051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66053
66054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66055   {
66056     try {
66057       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66058     } catch (std::out_of_range& e) {
66059       {
66060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66061       };
66062     } catch (std::exception& e) {
66063       {
66064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66065       };
66066     } catch (Dali::DaliException e) {
66067       {
66068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66069       };
66070     } catch (...) {
66071       {
66072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66073       };
66074     }
66075   }
66076
66077 }
66078
66079
66080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66082   Dali::Actor *arg2 = 0 ;
66083
66084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66085   arg2 = (Dali::Actor *)jarg2;
66086   if (!arg2) {
66087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66088     return ;
66089   }
66090   {
66091     try {
66092       (arg1)->OnControlChildAdd(*arg2);
66093     } catch (std::out_of_range& e) {
66094       {
66095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66096       };
66097     } catch (std::exception& e) {
66098       {
66099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66100       };
66101     } catch (Dali::DaliException e) {
66102       {
66103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66104       };
66105     } catch (...) {
66106       {
66107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66108       };
66109     }
66110   }
66111
66112 }
66113
66114
66115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66117   Dali::Actor *arg2 = 0 ;
66118
66119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66120   arg2 = (Dali::Actor *)jarg2;
66121   if (!arg2) {
66122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66123     return ;
66124   }
66125   {
66126     try {
66127       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66128     } catch (std::out_of_range& e) {
66129       {
66130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66131       };
66132     } catch (std::exception& e) {
66133       {
66134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66135       };
66136     } catch (Dali::DaliException e) {
66137       {
66138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66139       };
66140     } catch (...) {
66141       {
66142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66143       };
66144     }
66145   }
66146
66147 }
66148
66149
66150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66152   Dali::Actor *arg2 = 0 ;
66153
66154   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66155   arg2 = (Dali::Actor *)jarg2;
66156   if (!arg2) {
66157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66158     return ;
66159   }
66160   {
66161     try {
66162       (arg1)->OnControlChildRemove(*arg2);
66163     } catch (std::out_of_range& e) {
66164       {
66165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66166       };
66167     } catch (std::exception& e) {
66168       {
66169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66170       };
66171     } catch (Dali::DaliException e) {
66172       {
66173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66174       };
66175     } catch (...) {
66176       {
66177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66178       };
66179     }
66180   }
66181
66182 }
66183
66184
66185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66186   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66187   Dali::Actor *arg2 = 0 ;
66188
66189   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66190   arg2 = (Dali::Actor *)jarg2;
66191   if (!arg2) {
66192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66193     return ;
66194   }
66195   {
66196     try {
66197       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66198     } catch (std::out_of_range& e) {
66199       {
66200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66201       };
66202     } catch (std::exception& e) {
66203       {
66204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66205       };
66206     } catch (Dali::DaliException e) {
66207       {
66208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66209       };
66210     } catch (...) {
66211       {
66212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66213       };
66214     }
66215   }
66216
66217 }
66218
66219
66220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66221   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66222   Dali::Toolkit::StyleManager arg2 ;
66223   Dali::StyleChange::Type arg3 ;
66224   Dali::Toolkit::StyleManager *argp2 ;
66225
66226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66227   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66228   if (!argp2) {
66229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66230     return ;
66231   }
66232   arg2 = *argp2;
66233   arg3 = (Dali::StyleChange::Type)jarg3;
66234   {
66235     try {
66236       (arg1)->OnStyleChange(arg2,arg3);
66237     } catch (std::out_of_range& e) {
66238       {
66239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66240       };
66241     } catch (std::exception& e) {
66242       {
66243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66244       };
66245     } catch (Dali::DaliException e) {
66246       {
66247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66248       };
66249     } catch (...) {
66250       {
66251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66252       };
66253     }
66254   }
66255
66256 }
66257
66258
66259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66261   Dali::Toolkit::StyleManager arg2 ;
66262   Dali::StyleChange::Type arg3 ;
66263   Dali::Toolkit::StyleManager *argp2 ;
66264
66265   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66266   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66267   if (!argp2) {
66268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66269     return ;
66270   }
66271   arg2 = *argp2;
66272   arg3 = (Dali::StyleChange::Type)jarg3;
66273   {
66274     try {
66275       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66276     } catch (std::out_of_range& e) {
66277       {
66278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66279       };
66280     } catch (std::exception& e) {
66281       {
66282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66283       };
66284     } catch (Dali::DaliException e) {
66285       {
66286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66287       };
66288     } catch (...) {
66289       {
66290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66291       };
66292     }
66293   }
66294
66295 }
66296
66297
66298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66299   unsigned int jresult ;
66300   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66301   bool result;
66302
66303   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66304   {
66305     try {
66306       result = (bool)(arg1)->OnAccessibilityActivated();
66307     } catch (std::out_of_range& e) {
66308       {
66309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66310       };
66311     } catch (std::exception& e) {
66312       {
66313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66314       };
66315     } catch (Dali::DaliException e) {
66316       {
66317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66318       };
66319     } catch (...) {
66320       {
66321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66322       };
66323     }
66324   }
66325
66326   jresult = result;
66327   return jresult;
66328 }
66329
66330
66331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66332   unsigned int jresult ;
66333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66334   bool result;
66335
66336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66337   {
66338     try {
66339       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66340     } catch (std::out_of_range& e) {
66341       {
66342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66343       };
66344     } catch (std::exception& e) {
66345       {
66346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66347       };
66348     } catch (Dali::DaliException e) {
66349       {
66350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66351       };
66352     } catch (...) {
66353       {
66354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66355       };
66356     }
66357   }
66358
66359   jresult = result;
66360   return jresult;
66361 }
66362
66363
66364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66365   unsigned int jresult ;
66366   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66367   Dali::PanGesture arg2 ;
66368   Dali::PanGesture *argp2 ;
66369   bool result;
66370
66371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66372   argp2 = (Dali::PanGesture *)jarg2;
66373   if (!argp2) {
66374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66375     return 0;
66376   }
66377   arg2 = *argp2;
66378   {
66379     try {
66380       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66381     } catch (std::out_of_range& e) {
66382       {
66383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66384       };
66385     } catch (std::exception& e) {
66386       {
66387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66388       };
66389     } catch (Dali::DaliException e) {
66390       {
66391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66392       };
66393     } catch (...) {
66394       {
66395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66396       };
66397     }
66398   }
66399
66400   jresult = result;
66401   return jresult;
66402 }
66403
66404
66405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66406   unsigned int jresult ;
66407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66408   Dali::PanGesture arg2 ;
66409   Dali::PanGesture *argp2 ;
66410   bool result;
66411
66412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66413   argp2 = (Dali::PanGesture *)jarg2;
66414   if (!argp2) {
66415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66416     return 0;
66417   }
66418   arg2 = *argp2;
66419   {
66420     try {
66421       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66422     } catch (std::out_of_range& e) {
66423       {
66424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66425       };
66426     } catch (std::exception& e) {
66427       {
66428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66429       };
66430     } catch (Dali::DaliException e) {
66431       {
66432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66433       };
66434     } catch (...) {
66435       {
66436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66437       };
66438     }
66439   }
66440
66441   jresult = result;
66442   return jresult;
66443 }
66444
66445
66446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66447   unsigned int jresult ;
66448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66449   Dali::TouchEvent *arg2 = 0 ;
66450   bool result;
66451
66452   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66453   arg2 = (Dali::TouchEvent *)jarg2;
66454   if (!arg2) {
66455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66456     return 0;
66457   }
66458   {
66459     try {
66460       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66461     } catch (std::out_of_range& e) {
66462       {
66463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66464       };
66465     } catch (std::exception& e) {
66466       {
66467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66468       };
66469     } catch (Dali::DaliException e) {
66470       {
66471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66472       };
66473     } catch (...) {
66474       {
66475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66476       };
66477     }
66478   }
66479
66480   jresult = result;
66481   return jresult;
66482 }
66483
66484
66485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66486   unsigned int jresult ;
66487   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66488   Dali::TouchEvent *arg2 = 0 ;
66489   bool result;
66490
66491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66492   arg2 = (Dali::TouchEvent *)jarg2;
66493   if (!arg2) {
66494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66495     return 0;
66496   }
66497   {
66498     try {
66499       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66500     } catch (std::out_of_range& e) {
66501       {
66502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66503       };
66504     } catch (std::exception& e) {
66505       {
66506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66507       };
66508     } catch (Dali::DaliException e) {
66509       {
66510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66511       };
66512     } catch (...) {
66513       {
66514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66515       };
66516     }
66517   }
66518
66519   jresult = result;
66520   return jresult;
66521 }
66522
66523
66524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66525   unsigned int jresult ;
66526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66527   bool arg2 ;
66528   bool result;
66529
66530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66531   arg2 = jarg2 ? true : false;
66532   {
66533     try {
66534       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66535     } catch (std::out_of_range& e) {
66536       {
66537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66538       };
66539     } catch (std::exception& e) {
66540       {
66541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66542       };
66543     } catch (Dali::DaliException e) {
66544       {
66545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66546       };
66547     } catch (...) {
66548       {
66549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66550       };
66551     }
66552   }
66553
66554   jresult = result;
66555   return jresult;
66556 }
66557
66558
66559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66560   unsigned int jresult ;
66561   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66562   bool arg2 ;
66563   bool result;
66564
66565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66566   arg2 = jarg2 ? true : false;
66567   {
66568     try {
66569       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66570     } catch (std::out_of_range& e) {
66571       {
66572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66573       };
66574     } catch (std::exception& e) {
66575       {
66576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66577       };
66578     } catch (Dali::DaliException e) {
66579       {
66580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66581       };
66582     } catch (...) {
66583       {
66584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66585       };
66586     }
66587   }
66588
66589   jresult = result;
66590   return jresult;
66591 }
66592
66593
66594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66595   unsigned int jresult ;
66596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66597   bool result;
66598
66599   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66600   {
66601     try {
66602       result = (bool)(arg1)->OnAccessibilityZoom();
66603     } catch (std::out_of_range& e) {
66604       {
66605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66606       };
66607     } catch (std::exception& e) {
66608       {
66609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66610       };
66611     } catch (Dali::DaliException e) {
66612       {
66613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66614       };
66615     } catch (...) {
66616       {
66617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66618       };
66619     }
66620   }
66621
66622   jresult = result;
66623   return jresult;
66624 }
66625
66626
66627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66628   unsigned int jresult ;
66629   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66630   bool result;
66631
66632   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66633   {
66634     try {
66635       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66636     } catch (std::out_of_range& e) {
66637       {
66638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66639       };
66640     } catch (std::exception& e) {
66641       {
66642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66643       };
66644     } catch (Dali::DaliException e) {
66645       {
66646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66647       };
66648     } catch (...) {
66649       {
66650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66651       };
66652     }
66653   }
66654
66655   jresult = result;
66656   return jresult;
66657 }
66658
66659
66660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66661   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66662
66663   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66664   {
66665     try {
66666       (arg1)->OnKeyInputFocusGained();
66667     } catch (std::out_of_range& e) {
66668       {
66669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66670       };
66671     } catch (std::exception& e) {
66672       {
66673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66674       };
66675     } catch (Dali::DaliException e) {
66676       {
66677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66678       };
66679     } catch (...) {
66680       {
66681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66682       };
66683     }
66684   }
66685
66686 }
66687
66688
66689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66691
66692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66693   {
66694     try {
66695       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66696     } catch (std::out_of_range& e) {
66697       {
66698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66699       };
66700     } catch (std::exception& e) {
66701       {
66702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66703       };
66704     } catch (Dali::DaliException e) {
66705       {
66706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66707       };
66708     } catch (...) {
66709       {
66710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66711       };
66712     }
66713   }
66714
66715 }
66716
66717
66718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66720
66721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66722   {
66723     try {
66724       (arg1)->OnKeyInputFocusLost();
66725     } catch (std::out_of_range& e) {
66726       {
66727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66728       };
66729     } catch (std::exception& e) {
66730       {
66731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66732       };
66733     } catch (Dali::DaliException e) {
66734       {
66735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66736       };
66737     } catch (...) {
66738       {
66739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66740       };
66741     }
66742   }
66743
66744 }
66745
66746
66747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66749
66750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66751   {
66752     try {
66753       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66754     } catch (std::out_of_range& e) {
66755       {
66756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66757       };
66758     } catch (std::exception& e) {
66759       {
66760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66761       };
66762     } catch (Dali::DaliException e) {
66763       {
66764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66765       };
66766     } catch (...) {
66767       {
66768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66769       };
66770     }
66771   }
66772
66773 }
66774
66775
66776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66777   void * jresult ;
66778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66779   Dali::Actor arg2 ;
66780   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66781   bool arg4 ;
66782   Dali::Actor *argp2 ;
66783   Dali::Actor result;
66784
66785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66786   argp2 = (Dali::Actor *)jarg2;
66787   if (!argp2) {
66788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66789     return 0;
66790   }
66791   arg2 = *argp2;
66792   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66793   arg4 = jarg4 ? true : false;
66794   {
66795     try {
66796       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66797     } catch (std::out_of_range& e) {
66798       {
66799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66800       };
66801     } catch (std::exception& e) {
66802       {
66803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66804       };
66805     } catch (Dali::DaliException e) {
66806       {
66807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66808       };
66809     } catch (...) {
66810       {
66811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66812       };
66813     }
66814   }
66815
66816   jresult = new Dali::Actor((const Dali::Actor &)result);
66817   return jresult;
66818 }
66819
66820
66821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66822   void * jresult ;
66823   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66824   Dali::Actor arg2 ;
66825   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66826   bool arg4 ;
66827   Dali::Actor *argp2 ;
66828   Dali::Actor result;
66829
66830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66831   argp2 = (Dali::Actor *)jarg2;
66832   if (!argp2) {
66833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66834     return 0;
66835   }
66836   arg2 = *argp2;
66837   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66838   arg4 = jarg4 ? true : false;
66839   {
66840     try {
66841       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66842     } catch (std::out_of_range& e) {
66843       {
66844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66845       };
66846     } catch (std::exception& e) {
66847       {
66848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66849       };
66850     } catch (Dali::DaliException e) {
66851       {
66852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66853       };
66854     } catch (...) {
66855       {
66856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66857       };
66858     }
66859   }
66860
66861   jresult = new Dali::Actor((const Dali::Actor &)result);
66862   return jresult;
66863 }
66864
66865
66866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66867   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66868   Dali::Actor arg2 ;
66869   Dali::Actor *argp2 ;
66870
66871   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66872   argp2 = (Dali::Actor *)jarg2;
66873   if (!argp2) {
66874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66875     return ;
66876   }
66877   arg2 = *argp2;
66878   {
66879     try {
66880       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66881     } catch (std::out_of_range& e) {
66882       {
66883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66884       };
66885     } catch (std::exception& e) {
66886       {
66887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66888       };
66889     } catch (Dali::DaliException e) {
66890       {
66891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66892       };
66893     } catch (...) {
66894       {
66895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66896       };
66897     }
66898   }
66899
66900 }
66901
66902
66903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66904   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66905   Dali::Actor arg2 ;
66906   Dali::Actor *argp2 ;
66907
66908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66909   argp2 = (Dali::Actor *)jarg2;
66910   if (!argp2) {
66911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66912     return ;
66913   }
66914   arg2 = *argp2;
66915   {
66916     try {
66917       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66918     } catch (std::out_of_range& e) {
66919       {
66920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66921       };
66922     } catch (std::exception& e) {
66923       {
66924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66925       };
66926     } catch (Dali::DaliException e) {
66927       {
66928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66929       };
66930     } catch (...) {
66931       {
66932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66933       };
66934     }
66935   }
66936
66937 }
66938
66939
66940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66941   unsigned int jresult ;
66942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66943   bool result;
66944
66945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66946   {
66947     try {
66948       result = (bool)(arg1)->OnKeyboardEnter();
66949     } catch (std::out_of_range& e) {
66950       {
66951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66952       };
66953     } catch (std::exception& e) {
66954       {
66955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66956       };
66957     } catch (Dali::DaliException e) {
66958       {
66959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66960       };
66961     } catch (...) {
66962       {
66963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66964       };
66965     }
66966   }
66967
66968   jresult = result;
66969   return jresult;
66970 }
66971
66972
66973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66974   unsigned int jresult ;
66975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66976   bool result;
66977
66978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66979   {
66980     try {
66981       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66982     } catch (std::out_of_range& e) {
66983       {
66984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66985       };
66986     } catch (std::exception& e) {
66987       {
66988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66989       };
66990     } catch (Dali::DaliException e) {
66991       {
66992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66993       };
66994     } catch (...) {
66995       {
66996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66997       };
66998     }
66999   }
67000
67001   jresult = result;
67002   return jresult;
67003 }
67004
67005
67006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
67007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67008   Dali::PinchGesture *arg2 = 0 ;
67009
67010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67011   arg2 = (Dali::PinchGesture *)jarg2;
67012   if (!arg2) {
67013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67014     return ;
67015   }
67016   {
67017     try {
67018       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
67019     } catch (std::out_of_range& e) {
67020       {
67021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67022       };
67023     } catch (std::exception& e) {
67024       {
67025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67026       };
67027     } catch (Dali::DaliException e) {
67028       {
67029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67030       };
67031     } catch (...) {
67032       {
67033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67034       };
67035     }
67036   }
67037
67038 }
67039
67040
67041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67043   Dali::PinchGesture *arg2 = 0 ;
67044
67045   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67046   arg2 = (Dali::PinchGesture *)jarg2;
67047   if (!arg2) {
67048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67049     return ;
67050   }
67051   {
67052     try {
67053       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67054     } catch (std::out_of_range& e) {
67055       {
67056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67057       };
67058     } catch (std::exception& e) {
67059       {
67060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67061       };
67062     } catch (Dali::DaliException e) {
67063       {
67064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67065       };
67066     } catch (...) {
67067       {
67068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67069       };
67070     }
67071   }
67072
67073 }
67074
67075
67076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67078   Dali::PanGesture *arg2 = 0 ;
67079
67080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67081   arg2 = (Dali::PanGesture *)jarg2;
67082   if (!arg2) {
67083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67084     return ;
67085   }
67086   {
67087     try {
67088       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67089     } catch (std::out_of_range& e) {
67090       {
67091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67092       };
67093     } catch (std::exception& e) {
67094       {
67095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67096       };
67097     } catch (Dali::DaliException e) {
67098       {
67099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67100       };
67101     } catch (...) {
67102       {
67103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67104       };
67105     }
67106   }
67107
67108 }
67109
67110
67111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67113   Dali::PanGesture *arg2 = 0 ;
67114
67115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67116   arg2 = (Dali::PanGesture *)jarg2;
67117   if (!arg2) {
67118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67119     return ;
67120   }
67121   {
67122     try {
67123       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67124     } catch (std::out_of_range& e) {
67125       {
67126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67127       };
67128     } catch (std::exception& e) {
67129       {
67130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67131       };
67132     } catch (Dali::DaliException e) {
67133       {
67134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67135       };
67136     } catch (...) {
67137       {
67138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67139       };
67140     }
67141   }
67142
67143 }
67144
67145
67146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67148   Dali::TapGesture *arg2 = 0 ;
67149
67150   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67151   arg2 = (Dali::TapGesture *)jarg2;
67152   if (!arg2) {
67153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67154     return ;
67155   }
67156   {
67157     try {
67158       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67159     } catch (std::out_of_range& e) {
67160       {
67161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67162       };
67163     } catch (std::exception& e) {
67164       {
67165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67166       };
67167     } catch (Dali::DaliException e) {
67168       {
67169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67170       };
67171     } catch (...) {
67172       {
67173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67174       };
67175     }
67176   }
67177
67178 }
67179
67180
67181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67183   Dali::TapGesture *arg2 = 0 ;
67184
67185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67186   arg2 = (Dali::TapGesture *)jarg2;
67187   if (!arg2) {
67188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67189     return ;
67190   }
67191   {
67192     try {
67193       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67194     } catch (std::out_of_range& e) {
67195       {
67196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67197       };
67198     } catch (std::exception& e) {
67199       {
67200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67201       };
67202     } catch (Dali::DaliException e) {
67203       {
67204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67205       };
67206     } catch (...) {
67207       {
67208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67209       };
67210     }
67211   }
67212
67213 }
67214
67215
67216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67218   Dali::LongPressGesture *arg2 = 0 ;
67219
67220   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67221   arg2 = (Dali::LongPressGesture *)jarg2;
67222   if (!arg2) {
67223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67224     return ;
67225   }
67226   {
67227     try {
67228       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67229     } catch (std::out_of_range& e) {
67230       {
67231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67232       };
67233     } catch (std::exception& e) {
67234       {
67235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67236       };
67237     } catch (Dali::DaliException e) {
67238       {
67239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67240       };
67241     } catch (...) {
67242       {
67243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67244       };
67245     }
67246   }
67247
67248 }
67249
67250
67251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67253   Dali::LongPressGesture *arg2 = 0 ;
67254
67255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67256   arg2 = (Dali::LongPressGesture *)jarg2;
67257   if (!arg2) {
67258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67259     return ;
67260   }
67261   {
67262     try {
67263       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67264     } catch (std::out_of_range& e) {
67265       {
67266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67267       };
67268     } catch (std::exception& e) {
67269       {
67270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67271       };
67272     } catch (Dali::DaliException e) {
67273       {
67274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67275       };
67276     } catch (...) {
67277       {
67278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67279       };
67280     }
67281   }
67282
67283 }
67284
67285
67286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67288   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67289   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67290
67291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67292   arg2 = (Dali::SlotObserver *)jarg2;
67293   arg3 = (Dali::CallbackBase *)jarg3;
67294   {
67295     try {
67296       (arg1)->SignalConnected(arg2,arg3);
67297     } catch (std::out_of_range& e) {
67298       {
67299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67300       };
67301     } catch (std::exception& e) {
67302       {
67303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67304       };
67305     } catch (Dali::DaliException e) {
67306       {
67307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67308       };
67309     } catch (...) {
67310       {
67311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67312       };
67313     }
67314   }
67315
67316 }
67317
67318
67319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67320   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67321   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67322   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67323
67324   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67325   arg2 = (Dali::SlotObserver *)jarg2;
67326   arg3 = (Dali::CallbackBase *)jarg3;
67327   {
67328     try {
67329       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67330     } catch (std::out_of_range& e) {
67331       {
67332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67333       };
67334     } catch (std::exception& e) {
67335       {
67336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67337       };
67338     } catch (Dali::DaliException e) {
67339       {
67340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67341       };
67342     } catch (...) {
67343       {
67344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67345       };
67346     }
67347   }
67348
67349 }
67350
67351
67352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67353   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67354   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67355   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67356
67357   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67358   arg2 = (Dali::SlotObserver *)jarg2;
67359   arg3 = (Dali::CallbackBase *)jarg3;
67360   {
67361     try {
67362       (arg1)->SignalDisconnected(arg2,arg3);
67363     } catch (std::out_of_range& e) {
67364       {
67365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67366       };
67367     } catch (std::exception& e) {
67368       {
67369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67370       };
67371     } catch (Dali::DaliException e) {
67372       {
67373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67374       };
67375     } catch (...) {
67376       {
67377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67378       };
67379     }
67380   }
67381
67382 }
67383
67384
67385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67386   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67387   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67388   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67389
67390   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67391   arg2 = (Dali::SlotObserver *)jarg2;
67392   arg3 = (Dali::CallbackBase *)jarg3;
67393   {
67394     try {
67395       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67396     } catch (std::out_of_range& e) {
67397       {
67398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67399       };
67400     } catch (std::exception& e) {
67401       {
67402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67403       };
67404     } catch (Dali::DaliException e) {
67405       {
67406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67407       };
67408     } catch (...) {
67409       {
67410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67411       };
67412     }
67413   }
67414
67415 }
67416
67417
67418 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) {
67419   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67420   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67421   if (director) {
67422     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);
67423   }
67424 }
67425
67426
67427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67428   void * jresult ;
67429   Dali::Toolkit::Control *arg1 = 0 ;
67430   Dali::Toolkit::Internal::Control *result = 0 ;
67431
67432   arg1 = (Dali::Toolkit::Control *)jarg1;
67433   if (!arg1) {
67434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67435     return 0;
67436   }
67437   {
67438     try {
67439       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67440     } catch (std::out_of_range& e) {
67441       {
67442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67443       };
67444     } catch (std::exception& e) {
67445       {
67446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67447       };
67448     } catch (Dali::DaliException e) {
67449       {
67450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67451       };
67452     } catch (...) {
67453       {
67454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67455       };
67456     }
67457   }
67458
67459   jresult = (void *)result;
67460   return jresult;
67461 }
67462
67463
67464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67465   int jresult ;
67466   int result;
67467
67468   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67469   jresult = (int)result;
67470   return jresult;
67471 }
67472
67473
67474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67475   int jresult ;
67476   int result;
67477
67478   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67479   jresult = (int)result;
67480   return jresult;
67481 }
67482
67483
67484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67485   int jresult ;
67486   int result;
67487
67488   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67489   jresult = (int)result;
67490   return jresult;
67491 }
67492
67493
67494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67495   int jresult ;
67496   int result;
67497
67498   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67499   jresult = (int)result;
67500   return jresult;
67501 }
67502
67503
67504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67505   int jresult ;
67506   int result;
67507
67508   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67509   jresult = (int)result;
67510   return jresult;
67511 }
67512
67513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67514   int jresult ;
67515   int result;
67516
67517   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67518   jresult = (int)result;
67519   return jresult;
67520 }
67521
67522
67523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67524   int jresult ;
67525   int result;
67526
67527   result = (int)Dali::Toolkit::Control::Property::PADDING;
67528   jresult = (int)result;
67529   return jresult;
67530 }
67531
67532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67533   void * jresult ;
67534   Dali::Toolkit::Control::Property *result = 0 ;
67535
67536   {
67537     try {
67538       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67539     } catch (std::out_of_range& e) {
67540       {
67541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67542       };
67543     } catch (std::exception& e) {
67544       {
67545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67546       };
67547     } catch (Dali::DaliException e) {
67548       {
67549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67550       };
67551     } catch (...) {
67552       {
67553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67554       };
67555     }
67556   }
67557
67558   jresult = (void *)result;
67559   return jresult;
67560 }
67561
67562
67563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67564   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67565
67566   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67567   {
67568     try {
67569       delete arg1;
67570     } catch (std::out_of_range& e) {
67571       {
67572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67573       };
67574     } catch (std::exception& e) {
67575       {
67576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67577       };
67578     } catch (Dali::DaliException e) {
67579       {
67580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67581       };
67582     } catch (...) {
67583       {
67584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67585       };
67586     }
67587   }
67588
67589 }
67590
67591
67592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67593   void * jresult ;
67594   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67595
67596   {
67597     try {
67598       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67599     } catch (std::out_of_range& e) {
67600       {
67601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67602       };
67603     } catch (std::exception& e) {
67604       {
67605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67606       };
67607     } catch (Dali::DaliException e) {
67608       {
67609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67610       };
67611     } catch (...) {
67612       {
67613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67614       };
67615     }
67616   }
67617
67618   jresult = (void *)result;
67619   return jresult;
67620 }
67621
67622
67623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67624   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67625
67626   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67627   {
67628     try {
67629       delete arg1;
67630     } catch (std::out_of_range& e) {
67631       {
67632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67633       };
67634     } catch (std::exception& e) {
67635       {
67636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67637       };
67638     } catch (Dali::DaliException e) {
67639       {
67640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67641       };
67642     } catch (...) {
67643       {
67644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67645       };
67646     }
67647   }
67648
67649 }
67650
67651
67652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67653   void * jresult ;
67654   Dali::Toolkit::Control result;
67655
67656   {
67657     try {
67658       result = Dali::Toolkit::Control::New();
67659     } catch (std::out_of_range& e) {
67660       {
67661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67662       };
67663     } catch (std::exception& e) {
67664       {
67665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67666       };
67667     } catch (Dali::DaliException e) {
67668       {
67669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67670       };
67671     } catch (...) {
67672       {
67673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67674       };
67675     }
67676   }
67677
67678   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67679   return jresult;
67680 }
67681
67682
67683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67684   void * jresult ;
67685   Dali::Toolkit::Control *result = 0 ;
67686
67687   {
67688     try {
67689       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67690     } catch (std::out_of_range& e) {
67691       {
67692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67693       };
67694     } catch (std::exception& e) {
67695       {
67696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67697       };
67698     } catch (Dali::DaliException e) {
67699       {
67700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67701       };
67702     } catch (...) {
67703       {
67704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67705       };
67706     }
67707   }
67708
67709   jresult = (void *)result;
67710   return jresult;
67711 }
67712
67713
67714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67715   void * jresult ;
67716   Dali::Toolkit::Control *arg1 = 0 ;
67717   Dali::Toolkit::Control *result = 0 ;
67718
67719   arg1 = (Dali::Toolkit::Control *)jarg1;
67720   if (!arg1) {
67721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67722     return 0;
67723   }
67724   {
67725     try {
67726       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67727     } catch (std::out_of_range& e) {
67728       {
67729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67730       };
67731     } catch (std::exception& e) {
67732       {
67733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67734       };
67735     } catch (Dali::DaliException e) {
67736       {
67737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67738       };
67739     } catch (...) {
67740       {
67741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67742       };
67743     }
67744   }
67745
67746   jresult = (void *)result;
67747   return jresult;
67748 }
67749
67750
67751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67752   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67753
67754   arg1 = (Dali::Toolkit::Control *)jarg1;
67755   {
67756     try {
67757       delete arg1;
67758     } catch (std::out_of_range& e) {
67759       {
67760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67761       };
67762     } catch (std::exception& e) {
67763       {
67764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67765       };
67766     } catch (Dali::DaliException e) {
67767       {
67768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67769       };
67770     } catch (...) {
67771       {
67772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67773       };
67774     }
67775   }
67776
67777 }
67778
67779
67780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67781   void * jresult ;
67782   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67783   Dali::Toolkit::Control *arg2 = 0 ;
67784   Dali::Toolkit::Control *result = 0 ;
67785
67786   arg1 = (Dali::Toolkit::Control *)jarg1;
67787   arg2 = (Dali::Toolkit::Control *)jarg2;
67788   if (!arg2) {
67789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67790     return 0;
67791   }
67792   {
67793     try {
67794       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67795     } catch (std::out_of_range& e) {
67796       {
67797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67798       };
67799     } catch (std::exception& e) {
67800       {
67801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67802       };
67803     } catch (Dali::DaliException e) {
67804       {
67805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67806       };
67807     } catch (...) {
67808       {
67809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67810       };
67811     }
67812   }
67813
67814   jresult = (void *)result;
67815   return jresult;
67816 }
67817
67818
67819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67820   void * jresult ;
67821   Dali::BaseHandle arg1 ;
67822   Dali::BaseHandle *argp1 ;
67823   Dali::Toolkit::Control result;
67824
67825   argp1 = (Dali::BaseHandle *)jarg1;
67826   if (!argp1) {
67827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67828     return 0;
67829   }
67830   arg1 = *argp1;
67831   {
67832     try {
67833       result = Dali::Toolkit::Control::DownCast(arg1);
67834     } catch (std::out_of_range& e) {
67835       {
67836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67837       };
67838     } catch (std::exception& e) {
67839       {
67840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67841       };
67842     } catch (Dali::DaliException e) {
67843       {
67844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67845       };
67846     } catch (...) {
67847       {
67848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67849       };
67850     }
67851   }
67852
67853   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67854   return jresult;
67855 }
67856
67857
67858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67859   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67860
67861   arg1 = (Dali::Toolkit::Control *)jarg1;
67862   {
67863     try {
67864       (arg1)->SetKeyInputFocus();
67865     } catch (std::out_of_range& e) {
67866       {
67867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67868       };
67869     } catch (std::exception& e) {
67870       {
67871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67872       };
67873     } catch (Dali::DaliException e) {
67874       {
67875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67876       };
67877     } catch (...) {
67878       {
67879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67880       };
67881     }
67882   }
67883
67884 }
67885
67886
67887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67888   unsigned int jresult ;
67889   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67890   bool result;
67891
67892   arg1 = (Dali::Toolkit::Control *)jarg1;
67893   {
67894     try {
67895       result = (bool)(arg1)->HasKeyInputFocus();
67896     } catch (std::out_of_range& e) {
67897       {
67898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67899       };
67900     } catch (std::exception& e) {
67901       {
67902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67903       };
67904     } catch (Dali::DaliException e) {
67905       {
67906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67907       };
67908     } catch (...) {
67909       {
67910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67911       };
67912     }
67913   }
67914
67915   jresult = result;
67916   return jresult;
67917 }
67918
67919
67920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67921   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67922
67923   arg1 = (Dali::Toolkit::Control *)jarg1;
67924   {
67925     try {
67926       (arg1)->ClearKeyInputFocus();
67927     } catch (std::out_of_range& e) {
67928       {
67929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67930       };
67931     } catch (std::exception& e) {
67932       {
67933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67934       };
67935     } catch (Dali::DaliException e) {
67936       {
67937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67938       };
67939     } catch (...) {
67940       {
67941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67942       };
67943     }
67944   }
67945
67946 }
67947
67948
67949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67950   void * jresult ;
67951   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67952   Dali::PinchGestureDetector result;
67953
67954   arg1 = (Dali::Toolkit::Control *)jarg1;
67955   {
67956     try {
67957       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67958     } catch (std::out_of_range& e) {
67959       {
67960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67961       };
67962     } catch (std::exception& e) {
67963       {
67964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67965       };
67966     } catch (Dali::DaliException e) {
67967       {
67968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67969       };
67970     } catch (...) {
67971       {
67972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67973       };
67974     }
67975   }
67976
67977   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67978   return jresult;
67979 }
67980
67981
67982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67983   void * jresult ;
67984   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67985   Dali::PanGestureDetector result;
67986
67987   arg1 = (Dali::Toolkit::Control *)jarg1;
67988   {
67989     try {
67990       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67991     } catch (std::out_of_range& e) {
67992       {
67993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67994       };
67995     } catch (std::exception& e) {
67996       {
67997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67998       };
67999     } catch (Dali::DaliException e) {
68000       {
68001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68002       };
68003     } catch (...) {
68004       {
68005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68006       };
68007     }
68008   }
68009
68010   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
68011   return jresult;
68012 }
68013
68014
68015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
68016   void * jresult ;
68017   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68018   Dali::TapGestureDetector result;
68019
68020   arg1 = (Dali::Toolkit::Control *)jarg1;
68021   {
68022     try {
68023       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
68024     } catch (std::out_of_range& e) {
68025       {
68026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68027       };
68028     } catch (std::exception& e) {
68029       {
68030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68031       };
68032     } catch (Dali::DaliException e) {
68033       {
68034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68035       };
68036     } catch (...) {
68037       {
68038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68039       };
68040     }
68041   }
68042
68043   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68044   return jresult;
68045 }
68046
68047
68048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68049   void * jresult ;
68050   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68051   Dali::LongPressGestureDetector result;
68052
68053   arg1 = (Dali::Toolkit::Control *)jarg1;
68054   {
68055     try {
68056       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68057     } catch (std::out_of_range& e) {
68058       {
68059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68060       };
68061     } catch (std::exception& e) {
68062       {
68063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68064       };
68065     } catch (Dali::DaliException e) {
68066       {
68067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68068       };
68069     } catch (...) {
68070       {
68071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68072       };
68073     }
68074   }
68075
68076   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68077   return jresult;
68078 }
68079
68080
68081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68082   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68083   std::string *arg2 = 0 ;
68084
68085   arg1 = (Dali::Toolkit::Control *)jarg1;
68086   if (!jarg2) {
68087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68088     return ;
68089   }
68090   std::string arg2_str(jarg2);
68091   arg2 = &arg2_str;
68092   {
68093     try {
68094       (arg1)->SetStyleName((std::string const &)*arg2);
68095     } catch (std::out_of_range& e) {
68096       {
68097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68098       };
68099     } catch (std::exception& e) {
68100       {
68101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68102       };
68103     } catch (Dali::DaliException e) {
68104       {
68105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68106       };
68107     } catch (...) {
68108       {
68109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68110       };
68111     }
68112   }
68113
68114
68115   //argout typemap for const std::string&
68116
68117 }
68118
68119
68120 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68121   char * jresult ;
68122   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68123   std::string *result = 0 ;
68124
68125   arg1 = (Dali::Toolkit::Control *)jarg1;
68126   {
68127     try {
68128       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68129     } catch (std::out_of_range& e) {
68130       {
68131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68132       };
68133     } catch (std::exception& e) {
68134       {
68135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68136       };
68137     } catch (Dali::DaliException e) {
68138       {
68139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68140       };
68141     } catch (...) {
68142       {
68143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68144       };
68145     }
68146   }
68147
68148   jresult = SWIG_csharp_string_callback(result->c_str());
68149   return jresult;
68150 }
68151
68152
68153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68154   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68155   Dali::Vector4 *arg2 = 0 ;
68156
68157   arg1 = (Dali::Toolkit::Control *)jarg1;
68158   arg2 = (Dali::Vector4 *)jarg2;
68159   if (!arg2) {
68160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68161     return ;
68162   }
68163   {
68164     try {
68165       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68166     } catch (std::out_of_range& e) {
68167       {
68168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68169       };
68170     } catch (std::exception& e) {
68171       {
68172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68173       };
68174     } catch (Dali::DaliException e) {
68175       {
68176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68177       };
68178     } catch (...) {
68179       {
68180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68181       };
68182     }
68183   }
68184
68185 }
68186
68187
68188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68189   void * jresult ;
68190   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68191   Dali::Vector4 result;
68192
68193   arg1 = (Dali::Toolkit::Control *)jarg1;
68194   {
68195     try {
68196       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68197     } catch (std::out_of_range& e) {
68198       {
68199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68200       };
68201     } catch (std::exception& e) {
68202       {
68203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68204       };
68205     } catch (Dali::DaliException e) {
68206       {
68207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68208       };
68209     } catch (...) {
68210       {
68211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68212       };
68213     }
68214   }
68215
68216   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68217   return jresult;
68218 }
68219
68220
68221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68222   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68223   Dali::Image arg2 ;
68224   Dali::Image *argp2 ;
68225
68226   arg1 = (Dali::Toolkit::Control *)jarg1;
68227   argp2 = (Dali::Image *)jarg2;
68228   if (!argp2) {
68229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68230     return ;
68231   }
68232   arg2 = *argp2;
68233   {
68234     try {
68235       (arg1)->SetBackgroundImage(arg2);
68236     } catch (std::out_of_range& e) {
68237       {
68238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68239       };
68240     } catch (std::exception& e) {
68241       {
68242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68243       };
68244     } catch (Dali::DaliException e) {
68245       {
68246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68247       };
68248     } catch (...) {
68249       {
68250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68251       };
68252     }
68253   }
68254
68255 }
68256
68257
68258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68259   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68260
68261   arg1 = (Dali::Toolkit::Control *)jarg1;
68262   {
68263     try {
68264       (arg1)->ClearBackground();
68265     } catch (std::out_of_range& e) {
68266       {
68267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68268       };
68269     } catch (std::exception& e) {
68270       {
68271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68272       };
68273     } catch (Dali::DaliException e) {
68274       {
68275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68276       };
68277     } catch (...) {
68278       {
68279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68280       };
68281     }
68282   }
68283
68284 }
68285
68286
68287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68288   void * jresult ;
68289   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68290   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68291
68292   arg1 = (Dali::Toolkit::Control *)jarg1;
68293   {
68294     try {
68295       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68296     } catch (std::out_of_range& e) {
68297       {
68298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68299       };
68300     } catch (std::exception& e) {
68301       {
68302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68303       };
68304     } catch (Dali::DaliException e) {
68305       {
68306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68307       };
68308     } catch (...) {
68309       {
68310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68311       };
68312     }
68313   }
68314
68315   jresult = (void *)result;
68316   return jresult;
68317 }
68318
68319
68320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68321   void * jresult ;
68322   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68323   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68324
68325   arg1 = (Dali::Toolkit::Control *)jarg1;
68326   {
68327     try {
68328       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68329     } catch (std::out_of_range& e) {
68330       {
68331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68332       };
68333     } catch (std::exception& e) {
68334       {
68335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68336       };
68337     } catch (Dali::DaliException e) {
68338       {
68339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68340       };
68341     } catch (...) {
68342       {
68343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68344       };
68345     }
68346   }
68347
68348   jresult = (void *)result;
68349   return jresult;
68350 }
68351
68352
68353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68354   void * jresult ;
68355   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68356   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68357
68358   arg1 = (Dali::Toolkit::Control *)jarg1;
68359   {
68360     try {
68361       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68362     } catch (std::out_of_range& e) {
68363       {
68364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68365       };
68366     } catch (std::exception& e) {
68367       {
68368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68369       };
68370     } catch (Dali::DaliException e) {
68371       {
68372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68373       };
68374     } catch (...) {
68375       {
68376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68377       };
68378     }
68379   }
68380
68381   jresult = (void *)result;
68382   return jresult;
68383 }
68384
68385
68386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68387   void * jresult ;
68388   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68389   Dali::Toolkit::Control *result = 0 ;
68390
68391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68392   if (!arg1) {
68393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68394     return 0;
68395   }
68396   {
68397     try {
68398       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68399     } catch (std::out_of_range& e) {
68400       {
68401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68402       };
68403     } catch (std::exception& e) {
68404       {
68405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68406       };
68407     } catch (Dali::DaliException e) {
68408       {
68409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68410       };
68411     } catch (...) {
68412       {
68413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68414       };
68415     }
68416   }
68417
68418   jresult = (void *)result;
68419   return jresult;
68420 }
68421
68422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68423 {
68424   int jresult;
68425   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68426   arg1 = (Dali::Toolkit::Control *)jarg1;
68427
68428   if (!arg1) {
68429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68430     return 0;
68431   }
68432
68433   Dali::Property::Index arg2 = 0 ;
68434   arg2 = (Dali::Property::Index)jarg2;
68435
68436   Toolkit::Visual::ResourceStatus result;
68437   {
68438     try {
68439       result = arg1->GetVisualResourceStatus(arg2);
68440     } catch (std::out_of_range& e) {
68441       {
68442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68443       };
68444     } catch (std::exception& e) {
68445       {
68446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68447       };
68448     } catch (...) {
68449       {
68450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68451       };
68452     }
68453   }
68454   jresult = (int)(result);
68455   return jresult;
68456 }
68457
68458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68459 {
68460   void * jresult;
68461   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68462   arg1 = (Dali::Toolkit::Control *)jarg1;
68463
68464   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68465
68466   Dali::Toolkit::TransitionData *arg2 = 0 ;
68467   Dali::Animation result;
68468
68469   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68470   if (!arg2) {
68471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68472     return 0;
68473   }
68474   {
68475     try {
68476       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68477     } catch (std::out_of_range& e) {
68478       {
68479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68480       };
68481     } catch (std::exception& e) {
68482       {
68483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68484       };
68485     } catch (Dali::DaliException e) {
68486       {
68487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68488       };
68489     } catch (...) {
68490       {
68491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68492       };
68493     }
68494   }
68495
68496   jresult = new Dali::Animation((const Dali::Animation &)result);
68497   return jresult;
68498 }
68499
68500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68501 {
68502   Dali::Toolkit::Control arg1;
68503   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68504
68505   if (!argp1) {
68506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68507   }
68508   arg1 = *argp1;
68509
68510   Dali::Property::Index arg2 = 0 ;
68511   arg2 = (Dali::Property::Index)jarg2;
68512
68513   Dali::Property::Index arg3 = 0 ;
68514   arg3 = (Dali::Property::Index)jarg3;
68515
68516   Dali::Property::Value arg4;
68517   arg4 = (Dali::Property::Value *)jarg4;
68518
68519   {
68520     try {
68521       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68522     } catch (std::out_of_range& e) {
68523       {
68524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68525       };
68526     } catch (std::exception& e) {
68527       {
68528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68529       };
68530     } catch (...) {
68531       {
68532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68533       };
68534     }
68535   }
68536
68537
68538 }
68539
68540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68541   void * jresult ;
68542   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68543   Dali::Toolkit::LayoutItem result;
68544
68545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68546   if (!arg1) {
68547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68548     return 0;
68549   }
68550   {
68551     try {
68552       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68553     } catch (std::out_of_range& e) {
68554       {
68555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68556       };
68557     } catch (std::exception& e) {
68558       {
68559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68560       };
68561     } catch (...) {
68562       {
68563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68564       };
68565     }
68566   }
68567   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68568   return jresult;
68569 }
68570
68571
68572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68573   void * jresult ;
68574   Dali::Toolkit::Control arg1 ;
68575   Dali::Toolkit::Control *argp1 ;
68576   Dali::Toolkit::LayoutItem result;
68577
68578   argp1 = (Dali::Toolkit::Control *)jarg1;
68579   if (!argp1) {
68580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68581     return 0;
68582   }
68583   arg1 = *argp1;
68584   {
68585     try {
68586       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68587     } catch (std::out_of_range& e) {
68588       {
68589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68590       };
68591     } catch (std::exception& e) {
68592       {
68593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68594       };
68595     } catch (...) {
68596       {
68597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68598       };
68599     }
68600   }
68601   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68602   return jresult;
68603 }
68604
68605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68606   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68607   Dali::Toolkit::LayoutItem arg2 ;
68608   Dali::Toolkit::LayoutItem *argp2 ;
68609
68610   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68611   if (!arg1) {
68612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68613     return ;
68614   }
68615   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68616   if (!argp2) {
68617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68618     return ;
68619   }
68620   arg2 = *argp2;
68621   {
68622     try {
68623       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68624     } catch (std::out_of_range& e) {
68625       {
68626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68627       };
68628     } catch (std::exception& e) {
68629       {
68630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68631       };
68632     } catch (...) {
68633       {
68634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68635       };
68636     }
68637   }
68638 }
68639
68640
68641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68642   Dali::Toolkit::Control arg1 ;
68643   Dali::Toolkit::LayoutItem arg2 ;
68644   Dali::Toolkit::Control *argp1 ;
68645   Dali::Toolkit::LayoutItem *argp2 ;
68646
68647   argp1 = (Dali::Toolkit::Control *)jarg1;
68648   if (!argp1) {
68649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68650     return ;
68651   }
68652   arg1 = *argp1;
68653   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68654   if (!argp2) {
68655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68656     return ;
68657   }
68658   arg2 = *argp2;
68659   {
68660     try {
68661       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68662     } catch (std::out_of_range& e) {
68663       {
68664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68665       };
68666     } catch (std::exception& e) {
68667       {
68668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68669       };
68670     } catch (...) {
68671       {
68672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68673       };
68674     }
68675   }
68676 }
68677
68678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68679   void * jresult ;
68680   Dali::Toolkit::Control *arg1 = 0 ;
68681   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68682
68683   arg1 = (Dali::Toolkit::Control *)jarg1;
68684   if (!arg1) {
68685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68686     return 0;
68687   }
68688   {
68689     try {
68690       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68691     } catch (std::out_of_range& e) {
68692       {
68693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68694       };
68695     } catch (std::exception& e) {
68696       {
68697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68698       };
68699     } catch (Dali::DaliException e) {
68700       {
68701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68702       };
68703     } catch (...) {
68704       {
68705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68706       };
68707     }
68708   }
68709
68710   jresult = (void *)result;
68711   return jresult;
68712 }
68713
68714
68715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68716   unsigned int jresult ;
68717   Dali::Toolkit::Control *arg1 = 0 ;
68718   bool result;
68719
68720   arg1 = (Dali::Toolkit::Control *)jarg1;
68721   if (!arg1) {
68722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68723     return 0;
68724   }
68725   {
68726     try {
68727       result = (bool)arg1->IsResourceReady();
68728     } catch (std::out_of_range& e) {
68729       {
68730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68731       };
68732     } catch (std::exception& e) {
68733       {
68734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68735       };
68736     } catch (Dali::DaliException e) {
68737       {
68738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68739       };
68740     } catch (...) {
68741       {
68742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68743       };
68744     }
68745   }
68746
68747   jresult = result;
68748   return jresult;
68749 }
68750
68751
68752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68753   void * jresult ;
68754   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68755
68756   {
68757     try {
68758       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68759     } catch (std::out_of_range& e) {
68760       {
68761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68762       };
68763     } catch (std::exception& e) {
68764       {
68765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68766       };
68767     } catch (Dali::DaliException e) {
68768       {
68769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68770       };
68771     } catch (...) {
68772       {
68773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68774       };
68775     }
68776   }
68777
68778   jresult = (void *)result;
68779   return jresult;
68780 }
68781
68782
68783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68784   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68785
68786   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68787   {
68788     try {
68789       delete arg1;
68790     } catch (std::out_of_range& e) {
68791       {
68792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68793       };
68794     } catch (std::exception& e) {
68795       {
68796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68797       };
68798     } catch (Dali::DaliException e) {
68799       {
68800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68801       };
68802     } catch (...) {
68803       {
68804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68805       };
68806     }
68807   }
68808
68809 }
68810
68811
68812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68813   void * jresult ;
68814   Dali::Toolkit::KeyInputFocusManager result;
68815
68816   {
68817     try {
68818       result = Dali::Toolkit::KeyInputFocusManager::Get();
68819     } catch (std::out_of_range& e) {
68820       {
68821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68822       };
68823     } catch (std::exception& e) {
68824       {
68825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68826       };
68827     } catch (Dali::DaliException e) {
68828       {
68829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68830       };
68831     } catch (...) {
68832       {
68833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68834       };
68835     }
68836   }
68837
68838   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68839   return jresult;
68840 }
68841
68842
68843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68844   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68845   Dali::Toolkit::Control arg2 ;
68846   Dali::Toolkit::Control *argp2 ;
68847
68848   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68849   argp2 = (Dali::Toolkit::Control *)jarg2;
68850   if (!argp2) {
68851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68852     return ;
68853   }
68854   arg2 = *argp2;
68855   {
68856     try {
68857       (arg1)->SetFocus(arg2);
68858     } catch (std::out_of_range& e) {
68859       {
68860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68861       };
68862     } catch (std::exception& e) {
68863       {
68864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68865       };
68866     } catch (Dali::DaliException e) {
68867       {
68868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68869       };
68870     } catch (...) {
68871       {
68872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68873       };
68874     }
68875   }
68876
68877 }
68878
68879
68880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68881   void * jresult ;
68882   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68883   Dali::Toolkit::Control result;
68884
68885   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68886   {
68887     try {
68888       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68889     } catch (std::out_of_range& e) {
68890       {
68891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68892       };
68893     } catch (std::exception& e) {
68894       {
68895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68896       };
68897     } catch (Dali::DaliException e) {
68898       {
68899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68900       };
68901     } catch (...) {
68902       {
68903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68904       };
68905     }
68906   }
68907
68908   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68909   return jresult;
68910 }
68911
68912
68913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68914   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68915   Dali::Toolkit::Control arg2 ;
68916   Dali::Toolkit::Control *argp2 ;
68917
68918   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68919   argp2 = (Dali::Toolkit::Control *)jarg2;
68920   if (!argp2) {
68921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68922     return ;
68923   }
68924   arg2 = *argp2;
68925   {
68926     try {
68927       (arg1)->RemoveFocus(arg2);
68928     } catch (std::out_of_range& e) {
68929       {
68930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68931       };
68932     } catch (std::exception& e) {
68933       {
68934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68935       };
68936     } catch (Dali::DaliException e) {
68937       {
68938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68939       };
68940     } catch (...) {
68941       {
68942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68943       };
68944     }
68945   }
68946
68947 }
68948
68949
68950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68951   void * jresult ;
68952   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68953   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68954
68955   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68956   {
68957     try {
68958       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68959     } catch (std::out_of_range& e) {
68960       {
68961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68962       };
68963     } catch (std::exception& e) {
68964       {
68965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68966       };
68967     } catch (Dali::DaliException e) {
68968       {
68969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68970       };
68971     } catch (...) {
68972       {
68973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68974       };
68975     }
68976   }
68977
68978   jresult = (void *)result;
68979   return jresult;
68980 }
68981
68982
68983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68984   void * jresult ;
68985   Dali::Toolkit::Alignment::Padding *result = 0 ;
68986
68987   {
68988     try {
68989       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68990     } catch (std::out_of_range& e) {
68991       {
68992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68993       };
68994     } catch (std::exception& e) {
68995       {
68996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68997       };
68998     } catch (Dali::DaliException e) {
68999       {
69000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69001       };
69002     } catch (...) {
69003       {
69004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69005       };
69006     }
69007   }
69008
69009   jresult = (void *)result;
69010   return jresult;
69011 }
69012
69013
69014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69015   void * jresult ;
69016   float arg1 ;
69017   float arg2 ;
69018   float arg3 ;
69019   float arg4 ;
69020   Dali::Toolkit::Alignment::Padding *result = 0 ;
69021
69022   arg1 = (float)jarg1;
69023   arg2 = (float)jarg2;
69024   arg3 = (float)jarg3;
69025   arg4 = (float)jarg4;
69026   {
69027     try {
69028       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69029     } catch (std::out_of_range& e) {
69030       {
69031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69032       };
69033     } catch (std::exception& e) {
69034       {
69035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69036       };
69037     } catch (Dali::DaliException e) {
69038       {
69039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69040       };
69041     } catch (...) {
69042       {
69043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69044       };
69045     }
69046   }
69047
69048   jresult = (void *)result;
69049   return jresult;
69050 }
69051
69052
69053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69054   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69055   float arg2 ;
69056
69057   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69058   arg2 = (float)jarg2;
69059   if (arg1) (arg1)->left = arg2;
69060 }
69061
69062
69063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69064   float jresult ;
69065   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69066   float result;
69067
69068   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69069   result = (float) ((arg1)->left);
69070   jresult = result;
69071   return jresult;
69072 }
69073
69074
69075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69076   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69077   float arg2 ;
69078
69079   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69080   arg2 = (float)jarg2;
69081   if (arg1) (arg1)->right = arg2;
69082 }
69083
69084
69085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69086   float jresult ;
69087   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69088   float result;
69089
69090   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69091   result = (float) ((arg1)->right);
69092   jresult = result;
69093   return jresult;
69094 }
69095
69096
69097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69098   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69099   float arg2 ;
69100
69101   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69102   arg2 = (float)jarg2;
69103   if (arg1) (arg1)->top = arg2;
69104 }
69105
69106
69107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69108   float jresult ;
69109   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69110   float result;
69111
69112   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69113   result = (float) ((arg1)->top);
69114   jresult = result;
69115   return jresult;
69116 }
69117
69118
69119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69120   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69121   float arg2 ;
69122
69123   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69124   arg2 = (float)jarg2;
69125   if (arg1) (arg1)->bottom = arg2;
69126 }
69127
69128
69129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69130   float jresult ;
69131   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69132   float result;
69133
69134   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69135   result = (float) ((arg1)->bottom);
69136   jresult = result;
69137   return jresult;
69138 }
69139
69140
69141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69142   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69143
69144   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69145   {
69146     try {
69147       delete arg1;
69148     } catch (std::out_of_range& e) {
69149       {
69150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69151       };
69152     } catch (std::exception& e) {
69153       {
69154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69155       };
69156     } catch (Dali::DaliException e) {
69157       {
69158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69159       };
69160     } catch (...) {
69161       {
69162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69163       };
69164     }
69165   }
69166
69167 }
69168
69169
69170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69171   void * jresult ;
69172   Dali::Toolkit::Alignment *result = 0 ;
69173
69174   {
69175     try {
69176       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69177     } catch (std::out_of_range& e) {
69178       {
69179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69180       };
69181     } catch (std::exception& e) {
69182       {
69183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69184       };
69185     } catch (Dali::DaliException e) {
69186       {
69187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69188       };
69189     } catch (...) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69192       };
69193     }
69194   }
69195
69196   jresult = (void *)result;
69197   return jresult;
69198 }
69199
69200
69201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69202   void * jresult ;
69203   Dali::Toolkit::Alignment::Type arg1 ;
69204   Dali::Toolkit::Alignment::Type arg2 ;
69205   Dali::Toolkit::Alignment result;
69206
69207   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69208   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69209   {
69210     try {
69211       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69212     } catch (std::out_of_range& e) {
69213       {
69214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69215       };
69216     } catch (std::exception& e) {
69217       {
69218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69219       };
69220     } catch (Dali::DaliException e) {
69221       {
69222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69223       };
69224     } catch (...) {
69225       {
69226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69227       };
69228     }
69229   }
69230
69231   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69232   return jresult;
69233 }
69234
69235
69236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69237   void * jresult ;
69238   Dali::Toolkit::Alignment::Type arg1 ;
69239   Dali::Toolkit::Alignment result;
69240
69241   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69242   {
69243     try {
69244       result = Dali::Toolkit::Alignment::New(arg1);
69245     } catch (std::out_of_range& e) {
69246       {
69247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69248       };
69249     } catch (std::exception& e) {
69250       {
69251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69252       };
69253     } catch (Dali::DaliException e) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69256       };
69257     } catch (...) {
69258       {
69259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69260       };
69261     }
69262   }
69263
69264   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69265   return jresult;
69266 }
69267
69268
69269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69270   void * jresult ;
69271   Dali::Toolkit::Alignment result;
69272
69273   {
69274     try {
69275       result = Dali::Toolkit::Alignment::New();
69276     } catch (std::out_of_range& e) {
69277       {
69278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69279       };
69280     } catch (std::exception& e) {
69281       {
69282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69283       };
69284     } catch (Dali::DaliException e) {
69285       {
69286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69287       };
69288     } catch (...) {
69289       {
69290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69291       };
69292     }
69293   }
69294
69295   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69296   return jresult;
69297 }
69298
69299
69300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69301   void * jresult ;
69302   Dali::Toolkit::Alignment *arg1 = 0 ;
69303   Dali::Toolkit::Alignment *result = 0 ;
69304
69305   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69306   if (!arg1) {
69307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69308     return 0;
69309   }
69310   {
69311     try {
69312       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69313     } catch (std::out_of_range& e) {
69314       {
69315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69316       };
69317     } catch (std::exception& e) {
69318       {
69319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69320       };
69321     } catch (Dali::DaliException e) {
69322       {
69323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69324       };
69325     } catch (...) {
69326       {
69327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69328       };
69329     }
69330   }
69331
69332   jresult = (void *)result;
69333   return jresult;
69334 }
69335
69336
69337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69338   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69339
69340   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69341   {
69342     try {
69343       delete arg1;
69344     } catch (std::out_of_range& e) {
69345       {
69346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69347       };
69348     } catch (std::exception& e) {
69349       {
69350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69351       };
69352     } catch (Dali::DaliException e) {
69353       {
69354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69355       };
69356     } catch (...) {
69357       {
69358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69359       };
69360     }
69361   }
69362
69363 }
69364
69365
69366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69367   void * jresult ;
69368   Dali::BaseHandle arg1 ;
69369   Dali::BaseHandle *argp1 ;
69370   Dali::Toolkit::Alignment result;
69371
69372   argp1 = (Dali::BaseHandle *)jarg1;
69373   if (!argp1) {
69374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69375     return 0;
69376   }
69377   arg1 = *argp1;
69378   {
69379     try {
69380       result = Dali::Toolkit::Alignment::DownCast(arg1);
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 (Dali::DaliException e) {
69390       {
69391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69392       };
69393     } catch (...) {
69394       {
69395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69396       };
69397     }
69398   }
69399
69400   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69401   return jresult;
69402 }
69403
69404
69405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69406   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69407   Dali::Toolkit::Alignment::Type arg2 ;
69408
69409   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69410   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69411   {
69412     try {
69413       (arg1)->SetAlignmentType(arg2);
69414     } catch (std::out_of_range& e) {
69415       {
69416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69417       };
69418     } catch (std::exception& e) {
69419       {
69420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69421       };
69422     } catch (Dali::DaliException e) {
69423       {
69424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69425       };
69426     } catch (...) {
69427       {
69428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69429       };
69430     }
69431   }
69432
69433 }
69434
69435
69436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69437   int jresult ;
69438   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69439   Dali::Toolkit::Alignment::Type result;
69440
69441   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69442   {
69443     try {
69444       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69445     } catch (std::out_of_range& e) {
69446       {
69447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69448       };
69449     } catch (std::exception& e) {
69450       {
69451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69452       };
69453     } catch (Dali::DaliException e) {
69454       {
69455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69456       };
69457     } catch (...) {
69458       {
69459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69460       };
69461     }
69462   }
69463
69464   jresult = (int)result;
69465   return jresult;
69466 }
69467
69468
69469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69470   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69471   Dali::Toolkit::Alignment::Scaling arg2 ;
69472
69473   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69474   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69475   {
69476     try {
69477       (arg1)->SetScaling(arg2);
69478     } catch (std::out_of_range& e) {
69479       {
69480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69481       };
69482     } catch (std::exception& e) {
69483       {
69484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69485       };
69486     } catch (Dali::DaliException e) {
69487       {
69488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69489       };
69490     } catch (...) {
69491       {
69492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69493       };
69494     }
69495   }
69496
69497 }
69498
69499
69500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69501   int jresult ;
69502   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69503   Dali::Toolkit::Alignment::Scaling result;
69504
69505   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69506   {
69507     try {
69508       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69509     } catch (std::out_of_range& e) {
69510       {
69511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69512       };
69513     } catch (std::exception& e) {
69514       {
69515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69516       };
69517     } catch (Dali::DaliException e) {
69518       {
69519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69520       };
69521     } catch (...) {
69522       {
69523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69524       };
69525     }
69526   }
69527
69528   jresult = (int)result;
69529   return jresult;
69530 }
69531
69532
69533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69534   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69535   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69536
69537   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69538   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69539   if (!arg2) {
69540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69541     return ;
69542   }
69543   {
69544     try {
69545       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69546     } catch (std::out_of_range& e) {
69547       {
69548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69549       };
69550     } catch (std::exception& e) {
69551       {
69552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69553       };
69554     } catch (Dali::DaliException e) {
69555       {
69556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69557       };
69558     } catch (...) {
69559       {
69560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69561       };
69562     }
69563   }
69564
69565 }
69566
69567
69568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69569   void * jresult ;
69570   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69571   Dali::Toolkit::Alignment::Padding *result = 0 ;
69572
69573   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69574   {
69575     try {
69576       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69577     } catch (std::out_of_range& e) {
69578       {
69579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69580       };
69581     } catch (std::exception& e) {
69582       {
69583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69584       };
69585     } catch (Dali::DaliException e) {
69586       {
69587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69588       };
69589     } catch (...) {
69590       {
69591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69592       };
69593     }
69594   }
69595
69596   jresult = (void *)result;
69597   return jresult;
69598 }
69599
69600
69601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69602   void * jresult ;
69603   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69604   Dali::Toolkit::Alignment *arg2 = 0 ;
69605   Dali::Toolkit::Alignment *result = 0 ;
69606
69607   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69608   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69609   if (!arg2) {
69610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69611     return 0;
69612   }
69613   {
69614     try {
69615       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69616     } catch (std::out_of_range& e) {
69617       {
69618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69619       };
69620     } catch (std::exception& e) {
69621       {
69622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69623       };
69624     } catch (Dali::DaliException e) {
69625       {
69626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69627       };
69628     } catch (...) {
69629       {
69630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69631       };
69632     }
69633   }
69634
69635   jresult = (void *)result;
69636   return jresult;
69637 }
69638
69639
69640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69641   int jresult ;
69642   int result;
69643
69644   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69645   jresult = (int)result;
69646   return jresult;
69647 }
69648
69649
69650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69651   int jresult ;
69652   int result;
69653
69654   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69655   jresult = (int)result;
69656   return jresult;
69657 }
69658
69659
69660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69661   int jresult ;
69662   int result;
69663
69664   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69665   jresult = (int)result;
69666   return jresult;
69667 }
69668
69669
69670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69671   int jresult ;
69672   int result;
69673
69674   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69675   jresult = (int)result;
69676   return jresult;
69677 }
69678
69679
69680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69681   int jresult ;
69682   int result;
69683
69684   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69685   jresult = (int)result;
69686   return jresult;
69687 }
69688
69689
69690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69691   int jresult ;
69692   int result;
69693
69694   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69695   jresult = (int)result;
69696   return jresult;
69697 }
69698
69699
69700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69701   int jresult ;
69702   int result;
69703
69704   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69705   jresult = (int)result;
69706   return jresult;
69707 }
69708
69709
69710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69711   int jresult ;
69712   int result;
69713
69714   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69715   jresult = (int)result;
69716   return jresult;
69717 }
69718
69719
69720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69721   int jresult ;
69722   int result;
69723
69724   result = (int)Dali::Toolkit::Button::Property::LABEL;
69725   jresult = (int)result;
69726   return jresult;
69727 }
69728
69729
69730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69731   int jresult ;
69732   int result;
69733
69734   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69735   jresult = (int)result;
69736   return jresult;
69737 }
69738
69739
69740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69741   void * jresult ;
69742   Dali::Toolkit::Button::Property *result = 0 ;
69743
69744   {
69745     try {
69746       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69747     } catch (std::out_of_range& e) {
69748       {
69749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69750       };
69751     } catch (std::exception& e) {
69752       {
69753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69754       };
69755     } catch (Dali::DaliException e) {
69756       {
69757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69758       };
69759     } catch (...) {
69760       {
69761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69762       };
69763     }
69764   }
69765
69766   jresult = (void *)result;
69767   return jresult;
69768 }
69769
69770
69771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69772   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69773
69774   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69775   {
69776     try {
69777       delete arg1;
69778     } catch (std::out_of_range& e) {
69779       {
69780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69781       };
69782     } catch (std::exception& e) {
69783       {
69784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69785       };
69786     } catch (Dali::DaliException e) {
69787       {
69788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69789       };
69790     } catch (...) {
69791       {
69792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69793       };
69794     }
69795   }
69796
69797 }
69798
69799
69800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69801   void * jresult ;
69802   Dali::Toolkit::Button *result = 0 ;
69803
69804   {
69805     try {
69806       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69807     } catch (std::out_of_range& e) {
69808       {
69809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69810       };
69811     } catch (std::exception& e) {
69812       {
69813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69814       };
69815     } catch (Dali::DaliException e) {
69816       {
69817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69818       };
69819     } catch (...) {
69820       {
69821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69822       };
69823     }
69824   }
69825
69826   jresult = (void *)result;
69827   return jresult;
69828 }
69829
69830
69831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69832   void * jresult ;
69833   Dali::Toolkit::Button *arg1 = 0 ;
69834   Dali::Toolkit::Button *result = 0 ;
69835
69836   arg1 = (Dali::Toolkit::Button *)jarg1;
69837   if (!arg1) {
69838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69839     return 0;
69840   }
69841   {
69842     try {
69843       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69844     } catch (std::out_of_range& e) {
69845       {
69846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69847       };
69848     } catch (std::exception& e) {
69849       {
69850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69851       };
69852     } catch (Dali::DaliException e) {
69853       {
69854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69855       };
69856     } catch (...) {
69857       {
69858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69859       };
69860     }
69861   }
69862
69863   jresult = (void *)result;
69864   return jresult;
69865 }
69866
69867
69868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69869   void * jresult ;
69870   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69871   Dali::Toolkit::Button *arg2 = 0 ;
69872   Dali::Toolkit::Button *result = 0 ;
69873
69874   arg1 = (Dali::Toolkit::Button *)jarg1;
69875   arg2 = (Dali::Toolkit::Button *)jarg2;
69876   if (!arg2) {
69877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69878     return 0;
69879   }
69880   {
69881     try {
69882       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69883     } catch (std::out_of_range& e) {
69884       {
69885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69886       };
69887     } catch (std::exception& e) {
69888       {
69889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69890       };
69891     } catch (Dali::DaliException e) {
69892       {
69893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69894       };
69895     } catch (...) {
69896       {
69897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69898       };
69899     }
69900   }
69901
69902   jresult = (void *)result;
69903   return jresult;
69904 }
69905
69906
69907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69908   void * jresult ;
69909   Dali::BaseHandle arg1 ;
69910   Dali::BaseHandle *argp1 ;
69911   Dali::Toolkit::Button result;
69912
69913   argp1 = (Dali::BaseHandle *)jarg1;
69914   if (!argp1) {
69915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69916     return 0;
69917   }
69918   arg1 = *argp1;
69919   {
69920     try {
69921       result = Dali::Toolkit::Button::DownCast(arg1);
69922     } catch (std::out_of_range& e) {
69923       {
69924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69925       };
69926     } catch (std::exception& e) {
69927       {
69928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69929       };
69930     } catch (Dali::DaliException e) {
69931       {
69932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69933       };
69934     } catch (...) {
69935       {
69936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69937       };
69938     }
69939   }
69940
69941   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69942   return jresult;
69943 }
69944
69945
69946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69947   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69948
69949   arg1 = (Dali::Toolkit::Button *)jarg1;
69950   {
69951     try {
69952       delete arg1;
69953     } catch (std::out_of_range& e) {
69954       {
69955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69956       };
69957     } catch (std::exception& e) {
69958       {
69959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69960       };
69961     } catch (Dali::DaliException e) {
69962       {
69963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69964       };
69965     } catch (...) {
69966       {
69967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69968       };
69969     }
69970   }
69971
69972 }
69973
69974
69975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69976   unsigned int jresult ;
69977   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69978   bool result;
69979
69980   arg1 = (Dali::Toolkit::Button *)jarg1;
69981   {
69982     try {
69983       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69984     } catch (std::out_of_range& e) {
69985       {
69986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69987       };
69988     } catch (std::exception& e) {
69989       {
69990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69991       };
69992     } catch (Dali::DaliException e) {
69993       {
69994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69995       };
69996     } catch (...) {
69997       {
69998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69999       };
70000     }
70001   }
70002
70003   jresult = result;
70004   return jresult;
70005 }
70006
70007
70008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70009   unsigned int jresult ;
70010   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70011   bool result;
70012
70013   arg1 = (Dali::Toolkit::Button *)jarg1;
70014   {
70015     try {
70016       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70017     } catch (std::out_of_range& e) {
70018       {
70019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70020       };
70021     } catch (std::exception& e) {
70022       {
70023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70024       };
70025     } catch (Dali::DaliException e) {
70026       {
70027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70028       };
70029     } catch (...) {
70030       {
70031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70032       };
70033     }
70034   }
70035
70036   jresult = result;
70037   return jresult;
70038 }
70039
70040
70041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70042   float jresult ;
70043   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70044   float result;
70045
70046   arg1 = (Dali::Toolkit::Button *)jarg1;
70047   {
70048     try {
70049       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70050     } catch (std::out_of_range& e) {
70051       {
70052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70053       };
70054     } catch (std::exception& e) {
70055       {
70056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70057       };
70058     } catch (Dali::DaliException e) {
70059       {
70060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70061       };
70062     } catch (...) {
70063       {
70064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70065       };
70066     }
70067   }
70068
70069   jresult = result;
70070   return jresult;
70071 }
70072
70073
70074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70075   float jresult ;
70076   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70077   float result;
70078
70079   arg1 = (Dali::Toolkit::Button *)jarg1;
70080   {
70081     try {
70082       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70083     } catch (std::out_of_range& e) {
70084       {
70085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70086       };
70087     } catch (std::exception& e) {
70088       {
70089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70090       };
70091     } catch (Dali::DaliException e) {
70092       {
70093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70094       };
70095     } catch (...) {
70096       {
70097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70098       };
70099     }
70100   }
70101
70102   jresult = result;
70103   return jresult;
70104 }
70105
70106
70107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70108   unsigned int jresult ;
70109   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70110   bool result;
70111
70112   arg1 = (Dali::Toolkit::Button *)jarg1;
70113   {
70114     try {
70115       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70116     } catch (std::out_of_range& e) {
70117       {
70118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70119       };
70120     } catch (std::exception& e) {
70121       {
70122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70123       };
70124     } catch (Dali::DaliException e) {
70125       {
70126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70127       };
70128     } catch (...) {
70129       {
70130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70131       };
70132     }
70133   }
70134
70135   jresult = result;
70136   return jresult;
70137 }
70138
70139
70140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70141   unsigned int jresult ;
70142   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70143   bool result;
70144
70145   arg1 = (Dali::Toolkit::Button *)jarg1;
70146   {
70147     try {
70148       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70149     } catch (std::out_of_range& e) {
70150       {
70151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70152       };
70153     } catch (std::exception& e) {
70154       {
70155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70156       };
70157     } catch (Dali::DaliException e) {
70158       {
70159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70160       };
70161     } catch (...) {
70162       {
70163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70164       };
70165     }
70166   }
70167
70168   jresult = result;
70169   return jresult;
70170 }
70171
70172
70173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70174   float jresult ;
70175   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70176   float result;
70177
70178   arg1 = (Dali::Toolkit::Button *)jarg1;
70179   {
70180     try {
70181       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70182     } catch (std::out_of_range& e) {
70183       {
70184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70185       };
70186     } catch (std::exception& e) {
70187       {
70188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70189       };
70190     } catch (Dali::DaliException e) {
70191       {
70192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70193       };
70194     } catch (...) {
70195       {
70196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70197       };
70198     }
70199   }
70200
70201   jresult = result;
70202   return jresult;
70203 }
70204
70205
70206 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70207   char * jresult ;
70208   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70209   std::string result;
70210
70211   arg1 = (Dali::Toolkit::Button *)jarg1;
70212   {
70213     try {
70214       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70215     } catch (std::out_of_range& e) {
70216       {
70217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70218       };
70219     } catch (std::exception& e) {
70220       {
70221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70222       };
70223     } catch (Dali::DaliException e) {
70224       {
70225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70226       };
70227     } catch (...) {
70228       {
70229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70230       };
70231     }
70232   }
70233
70234   jresult = SWIG_csharp_string_callback((&result)->c_str());
70235   return jresult;
70236 }
70237
70238
70239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70240   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70241   Dali::Actor arg2 ;
70242   Dali::Actor *argp2 ;
70243
70244   arg1 = (Dali::Toolkit::Button *)jarg1;
70245   argp2 = (Dali::Actor *)jarg2;
70246   if (!argp2) {
70247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70248     return ;
70249   }
70250   arg2 = *argp2;
70251   {
70252     try {
70253       (arg1)->SetLabel(arg2);
70254     } catch (std::out_of_range& e) {
70255       {
70256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70257       };
70258     } catch (std::exception& e) {
70259       {
70260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70261       };
70262     } catch (Dali::DaliException e) {
70263       {
70264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70265       };
70266     } catch (...) {
70267       {
70268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70269       };
70270     }
70271   }
70272
70273 }
70274
70275
70276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70277   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70278   Dali::Image arg2 ;
70279   Dali::Image *argp2 ;
70280
70281   arg1 = (Dali::Toolkit::Button *)jarg1;
70282   argp2 = (Dali::Image *)jarg2;
70283   if (!argp2) {
70284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70285     return ;
70286   }
70287   arg2 = *argp2;
70288   {
70289     try {
70290       (arg1)->SetButtonImage(arg2);
70291     } catch (std::out_of_range& e) {
70292       {
70293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70294       };
70295     } catch (std::exception& e) {
70296       {
70297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70298       };
70299     } catch (Dali::DaliException e) {
70300       {
70301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70302       };
70303     } catch (...) {
70304       {
70305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70306       };
70307     }
70308   }
70309
70310 }
70311
70312
70313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70314   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70315   Dali::Image arg2 ;
70316   Dali::Image *argp2 ;
70317
70318   arg1 = (Dali::Toolkit::Button *)jarg1;
70319   argp2 = (Dali::Image *)jarg2;
70320   if (!argp2) {
70321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70322     return ;
70323   }
70324   arg2 = *argp2;
70325   {
70326     try {
70327       (arg1)->SetSelectedImage(arg2);
70328     } catch (std::out_of_range& e) {
70329       {
70330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70331       };
70332     } catch (std::exception& e) {
70333       {
70334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70335       };
70336     } catch (Dali::DaliException e) {
70337       {
70338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70339       };
70340     } catch (...) {
70341       {
70342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70343       };
70344     }
70345   }
70346
70347 }
70348
70349
70350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70351   void * jresult ;
70352   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70353   Dali::Actor result;
70354
70355   arg1 = (Dali::Toolkit::Button *)jarg1;
70356   {
70357     try {
70358       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70359     } catch (std::out_of_range& e) {
70360       {
70361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70362       };
70363     } catch (std::exception& e) {
70364       {
70365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70366       };
70367     } catch (Dali::DaliException e) {
70368       {
70369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70370       };
70371     } catch (...) {
70372       {
70373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70374       };
70375     }
70376   }
70377
70378   jresult = new Dali::Actor((const Dali::Actor &)result);
70379   return jresult;
70380 }
70381
70382
70383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70384   void * jresult ;
70385   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70386   Dali::Actor result;
70387
70388   arg1 = (Dali::Toolkit::Button *)jarg1;
70389   {
70390     try {
70391       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70392     } catch (std::out_of_range& e) {
70393       {
70394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70395       };
70396     } catch (std::exception& e) {
70397       {
70398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70399       };
70400     } catch (Dali::DaliException e) {
70401       {
70402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70403       };
70404     } catch (...) {
70405       {
70406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70407       };
70408     }
70409   }
70410
70411   jresult = new Dali::Actor((const Dali::Actor &)result);
70412   return jresult;
70413 }
70414
70415
70416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70417   void * jresult ;
70418   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70419   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70420
70421   arg1 = (Dali::Toolkit::Button *)jarg1;
70422   {
70423     try {
70424       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70425     } catch (std::out_of_range& e) {
70426       {
70427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70428       };
70429     } catch (std::exception& e) {
70430       {
70431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70432       };
70433     } catch (Dali::DaliException e) {
70434       {
70435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70436       };
70437     } catch (...) {
70438       {
70439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70440       };
70441     }
70442   }
70443
70444   jresult = (void *)result;
70445   return jresult;
70446 }
70447
70448
70449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70450   void * jresult ;
70451   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70452   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70453
70454   arg1 = (Dali::Toolkit::Button *)jarg1;
70455   {
70456     try {
70457       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70458     } catch (std::out_of_range& e) {
70459       {
70460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70461       };
70462     } catch (std::exception& e) {
70463       {
70464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70465       };
70466     } catch (Dali::DaliException e) {
70467       {
70468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70469       };
70470     } catch (...) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70473       };
70474     }
70475   }
70476
70477   jresult = (void *)result;
70478   return jresult;
70479 }
70480
70481
70482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70483   void * jresult ;
70484   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70485   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70486
70487   arg1 = (Dali::Toolkit::Button *)jarg1;
70488   {
70489     try {
70490       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70491     } catch (std::out_of_range& e) {
70492       {
70493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70494       };
70495     } catch (std::exception& e) {
70496       {
70497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70498       };
70499     } catch (Dali::DaliException e) {
70500       {
70501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70502       };
70503     } catch (...) {
70504       {
70505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70506       };
70507     }
70508   }
70509
70510   jresult = (void *)result;
70511   return jresult;
70512 }
70513
70514
70515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70516   void * jresult ;
70517   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70518   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70519
70520   arg1 = (Dali::Toolkit::Button *)jarg1;
70521   {
70522     try {
70523       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70524     } catch (std::out_of_range& e) {
70525       {
70526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70527       };
70528     } catch (std::exception& e) {
70529       {
70530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70531       };
70532     } catch (Dali::DaliException e) {
70533       {
70534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70535       };
70536     } catch (...) {
70537       {
70538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70539       };
70540     }
70541   }
70542
70543   jresult = (void *)result;
70544   return jresult;
70545 }
70546
70547
70548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70549   void * jresult ;
70550   Dali::Toolkit::CheckBoxButton *result = 0 ;
70551
70552   {
70553     try {
70554       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70555     } catch (std::out_of_range& e) {
70556       {
70557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70558       };
70559     } catch (std::exception& e) {
70560       {
70561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70562       };
70563     } catch (Dali::DaliException e) {
70564       {
70565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70566       };
70567     } catch (...) {
70568       {
70569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70570       };
70571     }
70572   }
70573
70574   jresult = (void *)result;
70575   return jresult;
70576 }
70577
70578
70579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70580   void * jresult ;
70581   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70582   Dali::Toolkit::CheckBoxButton *result = 0 ;
70583
70584   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70585   if (!arg1) {
70586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70587     return 0;
70588   }
70589   {
70590     try {
70591       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70592     } catch (std::out_of_range& e) {
70593       {
70594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70595       };
70596     } catch (std::exception& e) {
70597       {
70598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70599       };
70600     } catch (Dali::DaliException e) {
70601       {
70602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70603       };
70604     } catch (...) {
70605       {
70606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70607       };
70608     }
70609   }
70610
70611   jresult = (void *)result;
70612   return jresult;
70613 }
70614
70615
70616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70617   void * jresult ;
70618   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70619   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70620   Dali::Toolkit::CheckBoxButton *result = 0 ;
70621
70622   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70623   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70624   if (!arg2) {
70625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70626     return 0;
70627   }
70628   {
70629     try {
70630       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70631     } catch (std::out_of_range& e) {
70632       {
70633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70634       };
70635     } catch (std::exception& e) {
70636       {
70637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70638       };
70639     } catch (Dali::DaliException e) {
70640       {
70641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70642       };
70643     } catch (...) {
70644       {
70645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70646       };
70647     }
70648   }
70649
70650   jresult = (void *)result;
70651   return jresult;
70652 }
70653
70654
70655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70656   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70657
70658   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70659   {
70660     try {
70661       delete arg1;
70662     } catch (std::out_of_range& e) {
70663       {
70664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70665       };
70666     } catch (std::exception& e) {
70667       {
70668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70669       };
70670     } catch (Dali::DaliException e) {
70671       {
70672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70673       };
70674     } catch (...) {
70675       {
70676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70677       };
70678     }
70679   }
70680
70681 }
70682
70683
70684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70685   void * jresult ;
70686   Dali::Toolkit::CheckBoxButton result;
70687
70688   {
70689     try {
70690       result = Dali::Toolkit::CheckBoxButton::New();
70691     } catch (std::out_of_range& e) {
70692       {
70693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70694       };
70695     } catch (std::exception& e) {
70696       {
70697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70698       };
70699     } catch (Dali::DaliException e) {
70700       {
70701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70702       };
70703     } catch (...) {
70704       {
70705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70706       };
70707     }
70708   }
70709
70710   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70711   return jresult;
70712 }
70713
70714
70715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70716   void * jresult ;
70717   Dali::BaseHandle arg1 ;
70718   Dali::BaseHandle *argp1 ;
70719   Dali::Toolkit::CheckBoxButton result;
70720
70721   argp1 = (Dali::BaseHandle *)jarg1;
70722   if (!argp1) {
70723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70724     return 0;
70725   }
70726   arg1 = *argp1;
70727   {
70728     try {
70729       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70730     } catch (std::out_of_range& e) {
70731       {
70732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70733       };
70734     } catch (std::exception& e) {
70735       {
70736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70737       };
70738     } catch (Dali::DaliException e) {
70739       {
70740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70741       };
70742     } catch (...) {
70743       {
70744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70745       };
70746     }
70747   }
70748
70749   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70750   return jresult;
70751 }
70752
70753
70754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70755   int jresult ;
70756   int result;
70757
70758   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70759   jresult = (int)result;
70760   return jresult;
70761 }
70762
70763
70764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70765   int jresult ;
70766   int result;
70767
70768   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70769   jresult = (int)result;
70770   return jresult;
70771 }
70772
70773
70774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70775   int jresult ;
70776   int result;
70777
70778   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70779   jresult = (int)result;
70780   return jresult;
70781 }
70782
70783
70784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70785   int jresult ;
70786   int result;
70787
70788   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70789   jresult = (int)result;
70790   return jresult;
70791 }
70792
70793
70794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70795   int jresult ;
70796   int result;
70797
70798   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70799   jresult = (int)result;
70800   return jresult;
70801 }
70802
70803
70804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70805   void * jresult ;
70806   Dali::Toolkit::PushButton::Property *result = 0 ;
70807
70808   {
70809     try {
70810       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70811     } catch (std::out_of_range& e) {
70812       {
70813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70814       };
70815     } catch (std::exception& e) {
70816       {
70817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70818       };
70819     } catch (Dali::DaliException e) {
70820       {
70821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70822       };
70823     } catch (...) {
70824       {
70825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70826       };
70827     }
70828   }
70829
70830   jresult = (void *)result;
70831   return jresult;
70832 }
70833
70834
70835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70836   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70837
70838   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70839   {
70840     try {
70841       delete arg1;
70842     } catch (std::out_of_range& e) {
70843       {
70844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70845       };
70846     } catch (std::exception& e) {
70847       {
70848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70849       };
70850     } catch (Dali::DaliException e) {
70851       {
70852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70853       };
70854     } catch (...) {
70855       {
70856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70857       };
70858     }
70859   }
70860
70861 }
70862
70863
70864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70865   void * jresult ;
70866   Dali::Toolkit::PushButton *result = 0 ;
70867
70868   {
70869     try {
70870       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70871     } catch (std::out_of_range& e) {
70872       {
70873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70874       };
70875     } catch (std::exception& e) {
70876       {
70877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70878       };
70879     } catch (Dali::DaliException e) {
70880       {
70881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70882       };
70883     } catch (...) {
70884       {
70885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70886       };
70887     }
70888   }
70889
70890   jresult = (void *)result;
70891   return jresult;
70892 }
70893
70894
70895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70896   void * jresult ;
70897   Dali::Toolkit::PushButton *arg1 = 0 ;
70898   Dali::Toolkit::PushButton *result = 0 ;
70899
70900   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70901   if (!arg1) {
70902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70903     return 0;
70904   }
70905   {
70906     try {
70907       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70908     } catch (std::out_of_range& e) {
70909       {
70910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70911       };
70912     } catch (std::exception& e) {
70913       {
70914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70915       };
70916     } catch (Dali::DaliException e) {
70917       {
70918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70919       };
70920     } catch (...) {
70921       {
70922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70923       };
70924     }
70925   }
70926
70927   jresult = (void *)result;
70928   return jresult;
70929 }
70930
70931
70932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70933   void * jresult ;
70934   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70935   Dali::Toolkit::PushButton *arg2 = 0 ;
70936   Dali::Toolkit::PushButton *result = 0 ;
70937
70938   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70939   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70940   if (!arg2) {
70941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70942     return 0;
70943   }
70944   {
70945     try {
70946       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70947     } catch (std::out_of_range& e) {
70948       {
70949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70950       };
70951     } catch (std::exception& e) {
70952       {
70953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70954       };
70955     } catch (Dali::DaliException e) {
70956       {
70957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70958       };
70959     } catch (...) {
70960       {
70961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70962       };
70963     }
70964   }
70965
70966   jresult = (void *)result;
70967   return jresult;
70968 }
70969
70970
70971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70972   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70973
70974   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70975   {
70976     try {
70977       delete arg1;
70978     } catch (std::out_of_range& e) {
70979       {
70980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70981       };
70982     } catch (std::exception& e) {
70983       {
70984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70985       };
70986     } catch (Dali::DaliException e) {
70987       {
70988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70989       };
70990     } catch (...) {
70991       {
70992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70993       };
70994     }
70995   }
70996
70997 }
70998
70999
71000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
71001   void * jresult ;
71002   Dali::Toolkit::PushButton result;
71003
71004   {
71005     try {
71006       result = Dali::Toolkit::PushButton::New();
71007     } catch (std::out_of_range& e) {
71008       {
71009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71010       };
71011     } catch (std::exception& e) {
71012       {
71013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71014       };
71015     } catch (Dali::DaliException e) {
71016       {
71017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71018       };
71019     } catch (...) {
71020       {
71021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71022       };
71023     }
71024   }
71025
71026   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71027   return jresult;
71028 }
71029
71030
71031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71032   void * jresult ;
71033   Dali::BaseHandle arg1 ;
71034   Dali::BaseHandle *argp1 ;
71035   Dali::Toolkit::PushButton result;
71036
71037   argp1 = (Dali::BaseHandle *)jarg1;
71038   if (!argp1) {
71039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71040     return 0;
71041   }
71042   arg1 = *argp1;
71043   {
71044     try {
71045       result = Dali::Toolkit::PushButton::DownCast(arg1);
71046     } catch (std::out_of_range& e) {
71047       {
71048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71049       };
71050     } catch (std::exception& e) {
71051       {
71052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71053       };
71054     } catch (Dali::DaliException e) {
71055       {
71056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71057       };
71058     } catch (...) {
71059       {
71060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71061       };
71062     }
71063   }
71064
71065   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71066   return jresult;
71067 }
71068
71069
71070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71071   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71072   Dali::Image arg2 ;
71073   Dali::Image *argp2 ;
71074
71075   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71076   argp2 = (Dali::Image *)jarg2;
71077   if (!argp2) {
71078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71079     return ;
71080   }
71081   arg2 = *argp2;
71082   {
71083     try {
71084       (arg1)->SetButtonImage(arg2);
71085     } catch (std::out_of_range& e) {
71086       {
71087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71088       };
71089     } catch (std::exception& e) {
71090       {
71091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71092       };
71093     } catch (Dali::DaliException e) {
71094       {
71095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71096       };
71097     } catch (...) {
71098       {
71099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71100       };
71101     }
71102   }
71103
71104 }
71105
71106
71107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71108   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71109   Dali::Actor arg2 ;
71110   Dali::Actor *argp2 ;
71111
71112   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71113   argp2 = (Dali::Actor *)jarg2;
71114   if (!argp2) {
71115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71116     return ;
71117   }
71118   arg2 = *argp2;
71119   {
71120     try {
71121       (arg1)->SetButtonImage(arg2);
71122     } catch (std::out_of_range& e) {
71123       {
71124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71125       };
71126     } catch (std::exception& e) {
71127       {
71128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71129       };
71130     } catch (Dali::DaliException e) {
71131       {
71132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71133       };
71134     } catch (...) {
71135       {
71136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71137       };
71138     }
71139   }
71140
71141 }
71142
71143
71144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71145   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71146   Dali::Actor arg2 ;
71147   Dali::Actor *argp2 ;
71148
71149   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71150   argp2 = (Dali::Actor *)jarg2;
71151   if (!argp2) {
71152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71153     return ;
71154   }
71155   arg2 = *argp2;
71156   {
71157     try {
71158       (arg1)->SetBackgroundImage(arg2);
71159     } catch (std::out_of_range& e) {
71160       {
71161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71162       };
71163     } catch (std::exception& e) {
71164       {
71165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71166       };
71167     } catch (Dali::DaliException e) {
71168       {
71169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71170       };
71171     } catch (...) {
71172       {
71173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71174       };
71175     }
71176   }
71177
71178 }
71179
71180
71181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71182   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71183   Dali::Image arg2 ;
71184   Dali::Image *argp2 ;
71185
71186   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71187   argp2 = (Dali::Image *)jarg2;
71188   if (!argp2) {
71189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71190     return ;
71191   }
71192   arg2 = *argp2;
71193   {
71194     try {
71195       (arg1)->SetSelectedImage(arg2);
71196     } catch (std::out_of_range& e) {
71197       {
71198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71199       };
71200     } catch (std::exception& e) {
71201       {
71202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71203       };
71204     } catch (Dali::DaliException e) {
71205       {
71206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71207       };
71208     } catch (...) {
71209       {
71210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71211       };
71212     }
71213   }
71214
71215 }
71216
71217
71218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71219   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71220   Dali::Actor arg2 ;
71221   Dali::Actor *argp2 ;
71222
71223   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71224   argp2 = (Dali::Actor *)jarg2;
71225   if (!argp2) {
71226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71227     return ;
71228   }
71229   arg2 = *argp2;
71230   {
71231     try {
71232       (arg1)->SetSelectedImage(arg2);
71233     } catch (std::out_of_range& e) {
71234       {
71235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71236       };
71237     } catch (std::exception& e) {
71238       {
71239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71240       };
71241     } catch (Dali::DaliException e) {
71242       {
71243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71244       };
71245     } catch (...) {
71246       {
71247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71248       };
71249     }
71250   }
71251
71252 }
71253
71254
71255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71256   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71257   Dali::Actor arg2 ;
71258   Dali::Actor *argp2 ;
71259
71260   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71261   argp2 = (Dali::Actor *)jarg2;
71262   if (!argp2) {
71263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71264     return ;
71265   }
71266   arg2 = *argp2;
71267   {
71268     try {
71269       (arg1)->SetSelectedBackgroundImage(arg2);
71270     } catch (std::out_of_range& e) {
71271       {
71272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71273       };
71274     } catch (std::exception& e) {
71275       {
71276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71277       };
71278     } catch (Dali::DaliException e) {
71279       {
71280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71281       };
71282     } catch (...) {
71283       {
71284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71285       };
71286     }
71287   }
71288
71289 }
71290
71291
71292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71293   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71294   Dali::Actor arg2 ;
71295   Dali::Actor *argp2 ;
71296
71297   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71298   argp2 = (Dali::Actor *)jarg2;
71299   if (!argp2) {
71300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71301     return ;
71302   }
71303   arg2 = *argp2;
71304   {
71305     try {
71306       (arg1)->SetDisabledBackgroundImage(arg2);
71307     } catch (std::out_of_range& e) {
71308       {
71309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71310       };
71311     } catch (std::exception& e) {
71312       {
71313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71314       };
71315     } catch (Dali::DaliException e) {
71316       {
71317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71318       };
71319     } catch (...) {
71320       {
71321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71322       };
71323     }
71324   }
71325
71326 }
71327
71328
71329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71330   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71331   Dali::Actor arg2 ;
71332   Dali::Actor *argp2 ;
71333
71334   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71335   argp2 = (Dali::Actor *)jarg2;
71336   if (!argp2) {
71337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71338     return ;
71339   }
71340   arg2 = *argp2;
71341   {
71342     try {
71343       (arg1)->SetDisabledImage(arg2);
71344     } catch (std::out_of_range& e) {
71345       {
71346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71347       };
71348     } catch (std::exception& e) {
71349       {
71350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71351       };
71352     } catch (Dali::DaliException e) {
71353       {
71354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71355       };
71356     } catch (...) {
71357       {
71358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71359       };
71360     }
71361   }
71362
71363 }
71364
71365
71366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71367   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71368   Dali::Actor arg2 ;
71369   Dali::Actor *argp2 ;
71370
71371   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71372   argp2 = (Dali::Actor *)jarg2;
71373   if (!argp2) {
71374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71375     return ;
71376   }
71377   arg2 = *argp2;
71378   {
71379     try {
71380       (arg1)->SetDisabledSelectedImage(arg2);
71381     } catch (std::out_of_range& e) {
71382       {
71383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71384       };
71385     } catch (std::exception& e) {
71386       {
71387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71388       };
71389     } catch (Dali::DaliException e) {
71390       {
71391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71392       };
71393     } catch (...) {
71394       {
71395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71396       };
71397     }
71398   }
71399
71400 }
71401
71402
71403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71404   void * jresult ;
71405   Dali::Toolkit::RadioButton *result = 0 ;
71406
71407   {
71408     try {
71409       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71410     } catch (std::out_of_range& e) {
71411       {
71412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71413       };
71414     } catch (std::exception& e) {
71415       {
71416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71417       };
71418     } catch (Dali::DaliException e) {
71419       {
71420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71421       };
71422     } catch (...) {
71423       {
71424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71425       };
71426     }
71427   }
71428
71429   jresult = (void *)result;
71430   return jresult;
71431 }
71432
71433
71434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71435   void * jresult ;
71436   Dali::Toolkit::RadioButton *arg1 = 0 ;
71437   Dali::Toolkit::RadioButton *result = 0 ;
71438
71439   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71440   if (!arg1) {
71441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71442     return 0;
71443   }
71444   {
71445     try {
71446       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71447     } catch (std::out_of_range& e) {
71448       {
71449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71450       };
71451     } catch (std::exception& e) {
71452       {
71453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71454       };
71455     } catch (Dali::DaliException e) {
71456       {
71457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71458       };
71459     } catch (...) {
71460       {
71461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71462       };
71463     }
71464   }
71465
71466   jresult = (void *)result;
71467   return jresult;
71468 }
71469
71470
71471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71472   void * jresult ;
71473   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71474   Dali::Toolkit::RadioButton *arg2 = 0 ;
71475   Dali::Toolkit::RadioButton *result = 0 ;
71476
71477   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71478   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71479   if (!arg2) {
71480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71481     return 0;
71482   }
71483   {
71484     try {
71485       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71486     } catch (std::out_of_range& e) {
71487       {
71488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71489       };
71490     } catch (std::exception& e) {
71491       {
71492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71493       };
71494     } catch (Dali::DaliException e) {
71495       {
71496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71497       };
71498     } catch (...) {
71499       {
71500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71501       };
71502     }
71503   }
71504
71505   jresult = (void *)result;
71506   return jresult;
71507 }
71508
71509
71510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71511   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71512
71513   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71514   {
71515     try {
71516       delete arg1;
71517     } catch (std::out_of_range& e) {
71518       {
71519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71520       };
71521     } catch (std::exception& e) {
71522       {
71523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71524       };
71525     } catch (Dali::DaliException e) {
71526       {
71527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71528       };
71529     } catch (...) {
71530       {
71531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71532       };
71533     }
71534   }
71535
71536 }
71537
71538
71539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71540   void * jresult ;
71541   Dali::Toolkit::RadioButton result;
71542
71543   {
71544     try {
71545       result = Dali::Toolkit::RadioButton::New();
71546     } catch (std::out_of_range& e) {
71547       {
71548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71549       };
71550     } catch (std::exception& e) {
71551       {
71552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71553       };
71554     } catch (Dali::DaliException e) {
71555       {
71556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71557       };
71558     } catch (...) {
71559       {
71560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71561       };
71562     }
71563   }
71564
71565   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71566   return jresult;
71567 }
71568
71569
71570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71571   void * jresult ;
71572   std::string *arg1 = 0 ;
71573   Dali::Toolkit::RadioButton result;
71574
71575   if (!jarg1) {
71576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71577     return 0;
71578   }
71579   std::string arg1_str(jarg1);
71580   arg1 = &arg1_str;
71581   {
71582     try {
71583       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71584     } catch (std::out_of_range& e) {
71585       {
71586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71587       };
71588     } catch (std::exception& e) {
71589       {
71590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71591       };
71592     } catch (Dali::DaliException e) {
71593       {
71594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71595       };
71596     } catch (...) {
71597       {
71598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71599       };
71600     }
71601   }
71602
71603   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71604
71605   //argout typemap for const std::string&
71606
71607   return jresult;
71608 }
71609
71610
71611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71612   void * jresult ;
71613   Dali::BaseHandle arg1 ;
71614   Dali::BaseHandle *argp1 ;
71615   Dali::Toolkit::RadioButton result;
71616
71617   argp1 = (Dali::BaseHandle *)jarg1;
71618   if (!argp1) {
71619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71620     return 0;
71621   }
71622   arg1 = *argp1;
71623   {
71624     try {
71625       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71626     } catch (std::out_of_range& e) {
71627       {
71628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71629       };
71630     } catch (std::exception& e) {
71631       {
71632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71633       };
71634     } catch (Dali::DaliException e) {
71635       {
71636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71637       };
71638     } catch (...) {
71639       {
71640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71641       };
71642     }
71643   }
71644
71645   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71646   return jresult;
71647 }
71648
71649
71650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71651   int jresult ;
71652   int result;
71653
71654   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71655   jresult = (int)result;
71656   return jresult;
71657 }
71658
71659
71660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71661   int jresult ;
71662   int result;
71663
71664   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71665   jresult = (int)result;
71666   return jresult;
71667 }
71668
71669
71670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71671   int jresult ;
71672   int result;
71673
71674   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71675   jresult = (int)result;
71676   return jresult;
71677 }
71678
71679
71680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71681   int jresult ;
71682   int result;
71683
71684   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71685   jresult = (int)result;
71686   return jresult;
71687 }
71688
71689
71690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71691   int jresult ;
71692   int result;
71693
71694   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71695   jresult = (int)result;
71696   return jresult;
71697 }
71698
71699
71700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71701   int jresult ;
71702   int result;
71703
71704   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71705   jresult = (int)result;
71706   return jresult;
71707 }
71708
71709
71710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71711   void * jresult ;
71712   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71713
71714   {
71715     try {
71716       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71717     } catch (std::out_of_range& e) {
71718       {
71719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71720       };
71721     } catch (std::exception& e) {
71722       {
71723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71724       };
71725     } catch (Dali::DaliException e) {
71726       {
71727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71728       };
71729     } catch (...) {
71730       {
71731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71732       };
71733     }
71734   }
71735
71736   jresult = (void *)result;
71737   return jresult;
71738 }
71739
71740
71741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71742   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71743
71744   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71745   {
71746     try {
71747       delete arg1;
71748     } catch (std::out_of_range& e) {
71749       {
71750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71751       };
71752     } catch (std::exception& e) {
71753       {
71754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71755       };
71756     } catch (Dali::DaliException e) {
71757       {
71758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71759       };
71760     } catch (...) {
71761       {
71762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71763       };
71764     }
71765   }
71766
71767 }
71768
71769
71770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71771   int jresult ;
71772   int result;
71773
71774   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71775   jresult = (int)result;
71776   return jresult;
71777 }
71778
71779
71780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71781   int jresult ;
71782   int result;
71783
71784   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71785   jresult = (int)result;
71786   return jresult;
71787 }
71788
71789
71790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71791   int jresult ;
71792   int result;
71793
71794   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71795   jresult = (int)result;
71796   return jresult;
71797 }
71798
71799
71800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71801   void * jresult ;
71802   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71803
71804   {
71805     try {
71806       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71807     } catch (std::out_of_range& e) {
71808       {
71809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71810       };
71811     } catch (std::exception& e) {
71812       {
71813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71814       };
71815     } catch (Dali::DaliException e) {
71816       {
71817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71818       };
71819     } catch (...) {
71820       {
71821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71822       };
71823     }
71824   }
71825
71826   jresult = (void *)result;
71827   return jresult;
71828 }
71829
71830
71831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71832   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71833
71834   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71835   {
71836     try {
71837       delete arg1;
71838     } catch (std::out_of_range& e) {
71839       {
71840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71841       };
71842     } catch (std::exception& e) {
71843       {
71844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71845       };
71846     } catch (Dali::DaliException e) {
71847       {
71848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71849       };
71850     } catch (...) {
71851       {
71852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71853       };
71854     }
71855   }
71856
71857 }
71858
71859
71860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71861   void * jresult ;
71862   Dali::Toolkit::FlexContainer *result = 0 ;
71863
71864   {
71865     try {
71866       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71867     } catch (std::out_of_range& e) {
71868       {
71869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71870       };
71871     } catch (std::exception& e) {
71872       {
71873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71874       };
71875     } catch (Dali::DaliException e) {
71876       {
71877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71878       };
71879     } catch (...) {
71880       {
71881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71882       };
71883     }
71884   }
71885
71886   jresult = (void *)result;
71887   return jresult;
71888 }
71889
71890
71891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71892   void * jresult ;
71893   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71894   Dali::Toolkit::FlexContainer *result = 0 ;
71895
71896   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71897   if (!arg1) {
71898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71899     return 0;
71900   }
71901   {
71902     try {
71903       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71904     } catch (std::out_of_range& e) {
71905       {
71906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71907       };
71908     } catch (std::exception& e) {
71909       {
71910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71911       };
71912     } catch (Dali::DaliException e) {
71913       {
71914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71915       };
71916     } catch (...) {
71917       {
71918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71919       };
71920     }
71921   }
71922
71923   jresult = (void *)result;
71924   return jresult;
71925 }
71926
71927
71928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71929   void * jresult ;
71930   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71931   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71932   Dali::Toolkit::FlexContainer *result = 0 ;
71933
71934   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71935   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71936   if (!arg2) {
71937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71938     return 0;
71939   }
71940   {
71941     try {
71942       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71943     } catch (std::out_of_range& e) {
71944       {
71945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71946       };
71947     } catch (std::exception& e) {
71948       {
71949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71950       };
71951     } catch (Dali::DaliException e) {
71952       {
71953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71954       };
71955     } catch (...) {
71956       {
71957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71958       };
71959     }
71960   }
71961
71962   jresult = (void *)result;
71963   return jresult;
71964 }
71965
71966
71967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71968   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71969
71970   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71971   {
71972     try {
71973       delete arg1;
71974     } catch (std::out_of_range& e) {
71975       {
71976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71977       };
71978     } catch (std::exception& e) {
71979       {
71980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71981       };
71982     } catch (Dali::DaliException e) {
71983       {
71984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71985       };
71986     } catch (...) {
71987       {
71988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71989       };
71990     }
71991   }
71992
71993 }
71994
71995
71996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71997   void * jresult ;
71998   Dali::Toolkit::FlexContainer result;
71999
72000   {
72001     try {
72002       result = Dali::Toolkit::FlexContainer::New();
72003     } catch (std::out_of_range& e) {
72004       {
72005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72006       };
72007     } catch (std::exception& e) {
72008       {
72009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72010       };
72011     } catch (Dali::DaliException e) {
72012       {
72013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72014       };
72015     } catch (...) {
72016       {
72017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72018       };
72019     }
72020   }
72021
72022   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72023   return jresult;
72024 }
72025
72026
72027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72028   void * jresult ;
72029   Dali::BaseHandle arg1 ;
72030   Dali::BaseHandle *argp1 ;
72031   Dali::Toolkit::FlexContainer result;
72032
72033   argp1 = (Dali::BaseHandle *)jarg1;
72034   if (!argp1) {
72035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72036     return 0;
72037   }
72038   arg1 = *argp1;
72039   {
72040     try {
72041       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72042     } catch (std::out_of_range& e) {
72043       {
72044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72045       };
72046     } catch (std::exception& e) {
72047       {
72048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72049       };
72050     } catch (Dali::DaliException e) {
72051       {
72052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72053       };
72054     } catch (...) {
72055       {
72056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72057       };
72058     }
72059   }
72060
72061   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72062   return jresult;
72063 }
72064
72065
72066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72067   int jresult ;
72068   int result;
72069
72070   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72071   jresult = (int)result;
72072   return jresult;
72073 }
72074
72075
72076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72077   int jresult ;
72078   int result;
72079
72080   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72081   jresult = (int)result;
72082   return jresult;
72083 }
72084
72085
72086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72087   int jresult ;
72088   int result;
72089
72090   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72091   jresult = (int)result;
72092   return jresult;
72093 }
72094
72095
72096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72097   int jresult ;
72098   int result;
72099
72100   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72101   jresult = (int)result;
72102   return jresult;
72103 }
72104
72105
72106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72107   void * jresult ;
72108   Dali::Toolkit::ImageView::Property *result = 0 ;
72109
72110   {
72111     try {
72112       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72113     } catch (std::out_of_range& e) {
72114       {
72115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72116       };
72117     } catch (std::exception& e) {
72118       {
72119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72120       };
72121     } catch (Dali::DaliException e) {
72122       {
72123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72124       };
72125     } catch (...) {
72126       {
72127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72128       };
72129     }
72130   }
72131
72132   jresult = (void *)result;
72133   return jresult;
72134 }
72135
72136
72137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72138   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72139
72140   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72141   {
72142     try {
72143       delete arg1;
72144     } catch (std::out_of_range& e) {
72145       {
72146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72147       };
72148     } catch (std::exception& e) {
72149       {
72150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72151       };
72152     } catch (Dali::DaliException e) {
72153       {
72154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72155       };
72156     } catch (...) {
72157       {
72158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72159       };
72160     }
72161   }
72162
72163 }
72164
72165
72166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72167   void * jresult ;
72168   Dali::Toolkit::ImageView *result = 0 ;
72169
72170   {
72171     try {
72172       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72173     } catch (std::out_of_range& e) {
72174       {
72175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72176       };
72177     } catch (std::exception& e) {
72178       {
72179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72180       };
72181     } catch (Dali::DaliException e) {
72182       {
72183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72184       };
72185     } catch (...) {
72186       {
72187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72188       };
72189     }
72190   }
72191
72192   jresult = (void *)result;
72193   return jresult;
72194 }
72195
72196
72197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72198   void * jresult ;
72199   Dali::Toolkit::ImageView result;
72200
72201   {
72202     try {
72203       result = Dali::Toolkit::ImageView::New();
72204     } catch (std::out_of_range& e) {
72205       {
72206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72207       };
72208     } catch (std::exception& e) {
72209       {
72210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72211       };
72212     } catch (Dali::DaliException e) {
72213       {
72214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72215       };
72216     } catch (...) {
72217       {
72218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72219       };
72220     }
72221   }
72222
72223   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72224   return jresult;
72225 }
72226
72227
72228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72229   void * jresult ;
72230   Dali::Image arg1 ;
72231   Dali::Image *argp1 ;
72232   Dali::Toolkit::ImageView result;
72233
72234   argp1 = (Dali::Image *)jarg1;
72235   if (!argp1) {
72236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72237     return 0;
72238   }
72239   arg1 = *argp1;
72240   {
72241     try {
72242       result = Dali::Toolkit::ImageView::New(arg1);
72243     } catch (std::out_of_range& e) {
72244       {
72245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72246       };
72247     } catch (std::exception& e) {
72248       {
72249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72250       };
72251     } catch (Dali::DaliException e) {
72252       {
72253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72254       };
72255     } catch (...) {
72256       {
72257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72258       };
72259     }
72260   }
72261
72262   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72263   return jresult;
72264 }
72265
72266
72267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72268   void * jresult ;
72269   std::string *arg1 = 0 ;
72270   Dali::Toolkit::ImageView result;
72271
72272   if (!jarg1) {
72273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72274     return 0;
72275   }
72276   std::string arg1_str(jarg1);
72277   arg1 = &arg1_str;
72278   {
72279     try {
72280       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72281     } catch (std::out_of_range& e) {
72282       {
72283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72284       };
72285     } catch (std::exception& e) {
72286       {
72287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72288       };
72289     } catch (Dali::DaliException e) {
72290       {
72291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72292       };
72293     } catch (...) {
72294       {
72295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72296       };
72297     }
72298   }
72299
72300   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72301
72302   //argout typemap for const std::string&
72303
72304   return jresult;
72305 }
72306
72307
72308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72309   void * jresult ;
72310   std::string *arg1 = 0 ;
72311   Dali::ImageDimensions arg2 ;
72312   Dali::ImageDimensions *argp2 ;
72313   Dali::Toolkit::ImageView result;
72314
72315   if (!jarg1) {
72316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72317     return 0;
72318   }
72319   std::string arg1_str(jarg1);
72320   arg1 = &arg1_str;
72321   argp2 = (Dali::ImageDimensions *)jarg2;
72322   if (!argp2) {
72323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72324     return 0;
72325   }
72326   arg2 = *argp2;
72327   {
72328     try {
72329       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72330     } catch (std::out_of_range& e) {
72331       {
72332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72333       };
72334     } catch (std::exception& e) {
72335       {
72336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72337       };
72338     } catch (Dali::DaliException e) {
72339       {
72340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72341       };
72342     } catch (...) {
72343       {
72344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72345       };
72346     }
72347   }
72348
72349   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72350
72351   //argout typemap for const std::string&
72352
72353   return jresult;
72354 }
72355
72356
72357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72358   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72359
72360   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72361   {
72362     try {
72363       delete arg1;
72364     } catch (std::out_of_range& e) {
72365       {
72366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72367       };
72368     } catch (std::exception& e) {
72369       {
72370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72371       };
72372     } catch (Dali::DaliException e) {
72373       {
72374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72375       };
72376     } catch (...) {
72377       {
72378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72379       };
72380     }
72381   }
72382
72383 }
72384
72385
72386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72387   void * jresult ;
72388   Dali::Toolkit::ImageView *arg1 = 0 ;
72389   Dali::Toolkit::ImageView *result = 0 ;
72390
72391   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72392   if (!arg1) {
72393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72394     return 0;
72395   }
72396   {
72397     try {
72398       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72399     } catch (std::out_of_range& e) {
72400       {
72401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72402       };
72403     } catch (std::exception& e) {
72404       {
72405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72406       };
72407     } catch (Dali::DaliException e) {
72408       {
72409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72410       };
72411     } catch (...) {
72412       {
72413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72414       };
72415     }
72416   }
72417
72418   jresult = (void *)result;
72419   return jresult;
72420 }
72421
72422
72423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72424   void * jresult ;
72425   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72426   Dali::Toolkit::ImageView *arg2 = 0 ;
72427   Dali::Toolkit::ImageView *result = 0 ;
72428
72429   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72430   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72431   if (!arg2) {
72432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72433     return 0;
72434   }
72435   {
72436     try {
72437       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72438     } catch (std::out_of_range& e) {
72439       {
72440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72441       };
72442     } catch (std::exception& e) {
72443       {
72444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72445       };
72446     } catch (Dali::DaliException e) {
72447       {
72448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72449       };
72450     } catch (...) {
72451       {
72452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72453       };
72454     }
72455   }
72456
72457   jresult = (void *)result;
72458   return jresult;
72459 }
72460
72461
72462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72463   void * jresult ;
72464   Dali::BaseHandle arg1 ;
72465   Dali::BaseHandle *argp1 ;
72466   Dali::Toolkit::ImageView result;
72467
72468   argp1 = (Dali::BaseHandle *)jarg1;
72469   if (!argp1) {
72470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72471     return 0;
72472   }
72473   arg1 = *argp1;
72474   {
72475     try {
72476       result = Dali::Toolkit::ImageView::DownCast(arg1);
72477     } catch (std::out_of_range& e) {
72478       {
72479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72480       };
72481     } catch (std::exception& e) {
72482       {
72483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72484       };
72485     } catch (Dali::DaliException e) {
72486       {
72487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72488       };
72489     } catch (...) {
72490       {
72491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72492       };
72493     }
72494   }
72495
72496   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72497   return jresult;
72498 }
72499
72500
72501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72502   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72503   Dali::Image arg2 ;
72504   Dali::Image *argp2 ;
72505
72506   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72507   argp2 = (Dali::Image *)jarg2;
72508   if (!argp2) {
72509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72510     return ;
72511   }
72512   arg2 = *argp2;
72513   {
72514     try {
72515       (arg1)->SetImage(arg2);
72516     } catch (std::out_of_range& e) {
72517       {
72518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72519       };
72520     } catch (std::exception& e) {
72521       {
72522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72523       };
72524     } catch (Dali::DaliException e) {
72525       {
72526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72527       };
72528     } catch (...) {
72529       {
72530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72531       };
72532     }
72533   }
72534
72535 }
72536
72537
72538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72539   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72540   std::string *arg2 = 0 ;
72541
72542   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72543   if (!jarg2) {
72544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72545     return ;
72546   }
72547   std::string arg2_str(jarg2);
72548   arg2 = &arg2_str;
72549   {
72550     try {
72551       (arg1)->SetImage((std::string const &)*arg2);
72552     } catch (std::out_of_range& e) {
72553       {
72554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72555       };
72556     } catch (std::exception& e) {
72557       {
72558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72559       };
72560     } catch (Dali::DaliException e) {
72561       {
72562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72563       };
72564     } catch (...) {
72565       {
72566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72567       };
72568     }
72569   }
72570
72571
72572   //argout typemap for const std::string&
72573
72574 }
72575
72576
72577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72578   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72579   std::string *arg2 = 0 ;
72580   Dali::ImageDimensions arg3 ;
72581   Dali::ImageDimensions *argp3 ;
72582
72583   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72584   if (!jarg2) {
72585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72586     return ;
72587   }
72588   std::string arg2_str(jarg2);
72589   arg2 = &arg2_str;
72590   argp3 = (Dali::ImageDimensions *)jarg3;
72591   if (!argp3) {
72592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72593     return ;
72594   }
72595   arg3 = *argp3;
72596   {
72597     try {
72598       (arg1)->SetImage((std::string const &)*arg2,arg3);
72599     } catch (std::out_of_range& e) {
72600       {
72601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72602       };
72603     } catch (std::exception& e) {
72604       {
72605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72606       };
72607     } catch (Dali::DaliException e) {
72608       {
72609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72610       };
72611     } catch (...) {
72612       {
72613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72614       };
72615     }
72616   }
72617
72618
72619   //argout typemap for const std::string&
72620
72621 }
72622
72623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72624   void * jresult ;
72625   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72626   Dali::Image result;
72627
72628   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72629   {
72630     try {
72631       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72632     } catch (std::out_of_range& e) {
72633       {
72634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72635       };
72636     } catch (std::exception& e) {
72637       {
72638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72639       };
72640     } catch (Dali::DaliException e) {
72641       {
72642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72643       };
72644     } catch (...) {
72645       {
72646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72647       };
72648     }
72649   }
72650
72651   jresult = new Dali::Image((const Dali::Image &)result);
72652   return jresult;
72653 }
72654
72655
72656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72657   int jresult ;
72658   int result;
72659
72660   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72661   jresult = (int)result;
72662   return jresult;
72663 }
72664
72665
72666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72667   int jresult ;
72668   int result;
72669
72670   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72671   jresult = (int)result;
72672   return jresult;
72673 }
72674
72675
72676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72677   int jresult ;
72678   int result;
72679
72680   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72681   jresult = (int)result;
72682   return jresult;
72683 }
72684
72685
72686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72687   int jresult ;
72688   int result;
72689
72690   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72691   jresult = (int)result;
72692   return jresult;
72693 }
72694
72695
72696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72697   int jresult ;
72698   int result;
72699
72700   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72701   jresult = (int)result;
72702   return jresult;
72703 }
72704
72705
72706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72707   int jresult ;
72708   int result;
72709
72710   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72711   jresult = (int)result;
72712   return jresult;
72713 }
72714
72715
72716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72717   int jresult ;
72718   int result;
72719
72720   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72721   jresult = (int)result;
72722   return jresult;
72723 }
72724
72725
72726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72727   int jresult ;
72728   int result;
72729
72730   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72731   jresult = (int)result;
72732   return jresult;
72733 }
72734
72735
72736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72737   void * jresult ;
72738   Dali::Toolkit::Model3dView::Property *result = 0 ;
72739
72740   {
72741     try {
72742       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72743     } catch (std::out_of_range& e) {
72744       {
72745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72746       };
72747     } catch (std::exception& e) {
72748       {
72749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72750       };
72751     } catch (Dali::DaliException e) {
72752       {
72753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72754       };
72755     } catch (...) {
72756       {
72757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72758       };
72759     }
72760   }
72761
72762   jresult = (void *)result;
72763   return jresult;
72764 }
72765
72766
72767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72768   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72769
72770   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72771   {
72772     try {
72773       delete arg1;
72774     } catch (std::out_of_range& e) {
72775       {
72776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72777       };
72778     } catch (std::exception& e) {
72779       {
72780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72781       };
72782     } catch (Dali::DaliException e) {
72783       {
72784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72785       };
72786     } catch (...) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72789       };
72790     }
72791   }
72792
72793 }
72794
72795
72796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72797   void * jresult ;
72798   Dali::Toolkit::Model3dView result;
72799
72800   {
72801     try {
72802       result = Dali::Toolkit::Model3dView::New();
72803     } catch (std::out_of_range& e) {
72804       {
72805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72806       };
72807     } catch (std::exception& e) {
72808       {
72809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72810       };
72811     } catch (Dali::DaliException e) {
72812       {
72813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72814       };
72815     } catch (...) {
72816       {
72817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72818       };
72819     }
72820   }
72821
72822   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72823   return jresult;
72824 }
72825
72826
72827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72828   void * jresult ;
72829   std::string *arg1 = 0 ;
72830   std::string *arg2 = 0 ;
72831   std::string *arg3 = 0 ;
72832   Dali::Toolkit::Model3dView result;
72833
72834   if (!jarg1) {
72835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72836     return 0;
72837   }
72838   std::string arg1_str(jarg1);
72839   arg1 = &arg1_str;
72840   if (!jarg2) {
72841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72842     return 0;
72843   }
72844   std::string arg2_str(jarg2);
72845   arg2 = &arg2_str;
72846   if (!jarg3) {
72847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72848     return 0;
72849   }
72850   std::string arg3_str(jarg3);
72851   arg3 = &arg3_str;
72852   {
72853     try {
72854       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72855     } catch (std::out_of_range& e) {
72856       {
72857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72858       };
72859     } catch (std::exception& e) {
72860       {
72861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72862       };
72863     } catch (Dali::DaliException e) {
72864       {
72865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72866       };
72867     } catch (...) {
72868       {
72869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72870       };
72871     }
72872   }
72873
72874   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72875
72876   //argout typemap for const std::string&
72877
72878
72879   //argout typemap for const std::string&
72880
72881
72882   //argout typemap for const std::string&
72883
72884   return jresult;
72885 }
72886
72887
72888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72889   void * jresult ;
72890   Dali::Toolkit::Model3dView *result = 0 ;
72891
72892   {
72893     try {
72894       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72895     } catch (std::out_of_range& e) {
72896       {
72897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (std::exception& e) {
72900       {
72901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72902       };
72903     } catch (Dali::DaliException e) {
72904       {
72905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72906       };
72907     } catch (...) {
72908       {
72909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72910       };
72911     }
72912   }
72913
72914   jresult = (void *)result;
72915   return jresult;
72916 }
72917
72918
72919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72920   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72921
72922   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72923   {
72924     try {
72925       delete arg1;
72926     } catch (std::out_of_range& e) {
72927       {
72928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72929       };
72930     } catch (std::exception& e) {
72931       {
72932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72933       };
72934     } catch (Dali::DaliException e) {
72935       {
72936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72937       };
72938     } catch (...) {
72939       {
72940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72941       };
72942     }
72943   }
72944
72945 }
72946
72947
72948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72949   void * jresult ;
72950   Dali::Toolkit::Model3dView *arg1 = 0 ;
72951   Dali::Toolkit::Model3dView *result = 0 ;
72952
72953   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72954   if (!arg1) {
72955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72956     return 0;
72957   }
72958   {
72959     try {
72960       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72961     } catch (std::out_of_range& e) {
72962       {
72963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72964       };
72965     } catch (std::exception& e) {
72966       {
72967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72968       };
72969     } catch (Dali::DaliException e) {
72970       {
72971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72972       };
72973     } catch (...) {
72974       {
72975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72976       };
72977     }
72978   }
72979
72980   jresult = (void *)result;
72981   return jresult;
72982 }
72983
72984
72985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72986   void * jresult ;
72987   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72988   Dali::Toolkit::Model3dView *arg2 = 0 ;
72989   Dali::Toolkit::Model3dView *result = 0 ;
72990
72991   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72992   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72993   if (!arg2) {
72994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72995     return 0;
72996   }
72997   {
72998     try {
72999       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
73000     } catch (std::out_of_range& e) {
73001       {
73002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73003       };
73004     } catch (std::exception& e) {
73005       {
73006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73007       };
73008     } catch (Dali::DaliException e) {
73009       {
73010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73011       };
73012     } catch (...) {
73013       {
73014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73015       };
73016     }
73017   }
73018
73019   jresult = (void *)result;
73020   return jresult;
73021 }
73022
73023
73024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
73025   void * jresult ;
73026   Dali::BaseHandle arg1 ;
73027   Dali::BaseHandle *argp1 ;
73028   Dali::Toolkit::Model3dView result;
73029
73030   argp1 = (Dali::BaseHandle *)jarg1;
73031   if (!argp1) {
73032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73033     return 0;
73034   }
73035   arg1 = *argp1;
73036   {
73037     try {
73038       result = Dali::Toolkit::Model3dView::DownCast(arg1);
73039     } catch (std::out_of_range& e) {
73040       {
73041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73042       };
73043     } catch (std::exception& e) {
73044       {
73045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73046       };
73047     } catch (Dali::DaliException e) {
73048       {
73049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73050       };
73051     } catch (...) {
73052       {
73053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73054       };
73055     }
73056   }
73057
73058   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73059   return jresult;
73060 }
73061
73062
73063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73064   int jresult ;
73065   int result;
73066
73067   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73068   jresult = (int)result;
73069   return jresult;
73070 }
73071
73072
73073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73074   int jresult ;
73075   int result;
73076
73077   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73078   jresult = (int)result;
73079   return jresult;
73080 }
73081
73082
73083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73084   int jresult ;
73085   int result;
73086
73087   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73088   jresult = (int)result;
73089   return jresult;
73090 }
73091
73092
73093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73094   int jresult ;
73095   int result;
73096
73097   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73098   jresult = (int)result;
73099   return jresult;
73100 }
73101
73102
73103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73104   int jresult ;
73105   int result;
73106
73107   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73108   jresult = (int)result;
73109   return jresult;
73110 }
73111
73112
73113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73114   int jresult ;
73115   int result;
73116
73117   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73118   jresult = (int)result;
73119   return jresult;
73120 }
73121
73122
73123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73124   int jresult ;
73125   int result;
73126
73127   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73128   jresult = (int)result;
73129   return jresult;
73130 }
73131
73132
73133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73134   int jresult ;
73135   int result;
73136
73137   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73138   jresult = (int)result;
73139   return jresult;
73140 }
73141
73142
73143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73144   int jresult ;
73145   int result;
73146
73147   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73148   jresult = (int)result;
73149   return jresult;
73150 }
73151
73152
73153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73154   void * jresult ;
73155   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73156
73157   {
73158     try {
73159       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73160     } catch (std::out_of_range& e) {
73161       {
73162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73163       };
73164     } catch (std::exception& e) {
73165       {
73166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73167       };
73168     } catch (Dali::DaliException e) {
73169       {
73170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73171       };
73172     } catch (...) {
73173       {
73174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73175       };
73176     }
73177   }
73178
73179   jresult = (void *)result;
73180   return jresult;
73181 }
73182
73183
73184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73185   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73186
73187   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73188   {
73189     try {
73190       delete arg1;
73191     } catch (std::out_of_range& e) {
73192       {
73193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73194       };
73195     } catch (std::exception& e) {
73196       {
73197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73198       };
73199     } catch (Dali::DaliException e) {
73200       {
73201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73202       };
73203     } catch (...) {
73204       {
73205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73206       };
73207     }
73208   }
73209
73210 }
73211
73212
73213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73214   void * jresult ;
73215   Dali::Toolkit::ScrollBar *result = 0 ;
73216
73217   {
73218     try {
73219       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73220     } catch (std::out_of_range& e) {
73221       {
73222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73223       };
73224     } catch (std::exception& e) {
73225       {
73226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73227       };
73228     } catch (Dali::DaliException e) {
73229       {
73230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73231       };
73232     } catch (...) {
73233       {
73234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73235       };
73236     }
73237   }
73238
73239   jresult = (void *)result;
73240   return jresult;
73241 }
73242
73243
73244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73245   void * jresult ;
73246   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73247   Dali::Toolkit::ScrollBar *result = 0 ;
73248
73249   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73250   if (!arg1) {
73251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73252     return 0;
73253   }
73254   {
73255     try {
73256       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73257     } catch (std::out_of_range& e) {
73258       {
73259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73260       };
73261     } catch (std::exception& e) {
73262       {
73263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73264       };
73265     } catch (Dali::DaliException e) {
73266       {
73267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73268       };
73269     } catch (...) {
73270       {
73271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73272       };
73273     }
73274   }
73275
73276   jresult = (void *)result;
73277   return jresult;
73278 }
73279
73280
73281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73282   void * jresult ;
73283   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73284   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73285   Dali::Toolkit::ScrollBar *result = 0 ;
73286
73287   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73288   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73289   if (!arg2) {
73290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73291     return 0;
73292   }
73293   {
73294     try {
73295       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73296     } catch (std::out_of_range& e) {
73297       {
73298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73299       };
73300     } catch (std::exception& e) {
73301       {
73302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73303       };
73304     } catch (Dali::DaliException e) {
73305       {
73306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73307       };
73308     } catch (...) {
73309       {
73310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73311       };
73312     }
73313   }
73314
73315   jresult = (void *)result;
73316   return jresult;
73317 }
73318
73319
73320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73321   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73322
73323   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73324   {
73325     try {
73326       delete arg1;
73327     } catch (std::out_of_range& e) {
73328       {
73329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73330       };
73331     } catch (std::exception& e) {
73332       {
73333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73334       };
73335     } catch (Dali::DaliException e) {
73336       {
73337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73338       };
73339     } catch (...) {
73340       {
73341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73342       };
73343     }
73344   }
73345
73346 }
73347
73348
73349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73350   void * jresult ;
73351   Dali::Toolkit::ScrollBar::Direction arg1 ;
73352   Dali::Toolkit::ScrollBar result;
73353
73354   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73355   {
73356     try {
73357       result = Dali::Toolkit::ScrollBar::New(arg1);
73358     } catch (std::out_of_range& e) {
73359       {
73360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73361       };
73362     } catch (std::exception& e) {
73363       {
73364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73365       };
73366     } catch (Dali::DaliException e) {
73367       {
73368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73369       };
73370     } catch (...) {
73371       {
73372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73373       };
73374     }
73375   }
73376
73377   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73378   return jresult;
73379 }
73380
73381
73382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73383   void * jresult ;
73384   Dali::Toolkit::ScrollBar result;
73385
73386   {
73387     try {
73388       result = Dali::Toolkit::ScrollBar::New();
73389     } catch (std::out_of_range& e) {
73390       {
73391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73392       };
73393     } catch (std::exception& e) {
73394       {
73395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73396       };
73397     } catch (Dali::DaliException e) {
73398       {
73399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73400       };
73401     } catch (...) {
73402       {
73403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73404       };
73405     }
73406   }
73407
73408   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73409   return jresult;
73410 }
73411
73412
73413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73414   void * jresult ;
73415   Dali::BaseHandle arg1 ;
73416   Dali::BaseHandle *argp1 ;
73417   Dali::Toolkit::ScrollBar result;
73418
73419   argp1 = (Dali::BaseHandle *)jarg1;
73420   if (!argp1) {
73421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73422     return 0;
73423   }
73424   arg1 = *argp1;
73425   {
73426     try {
73427       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73428     } catch (std::out_of_range& e) {
73429       {
73430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73431       };
73432     } catch (std::exception& e) {
73433       {
73434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73435       };
73436     } catch (Dali::DaliException e) {
73437       {
73438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73439       };
73440     } catch (...) {
73441       {
73442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73443       };
73444     }
73445   }
73446
73447   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73448   return jresult;
73449 }
73450
73451
73452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73453   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73454   Dali::Handle arg2 ;
73455   Dali::Property::Index arg3 ;
73456   Dali::Property::Index arg4 ;
73457   Dali::Property::Index arg5 ;
73458   Dali::Property::Index arg6 ;
73459   Dali::Handle *argp2 ;
73460
73461   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73462   argp2 = (Dali::Handle *)jarg2;
73463   if (!argp2) {
73464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73465     return ;
73466   }
73467   arg2 = *argp2;
73468   arg3 = (Dali::Property::Index)jarg3;
73469   arg4 = (Dali::Property::Index)jarg4;
73470   arg5 = (Dali::Property::Index)jarg5;
73471   arg6 = (Dali::Property::Index)jarg6;
73472   {
73473     try {
73474       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73475     } catch (std::out_of_range& e) {
73476       {
73477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73478       };
73479     } catch (std::exception& e) {
73480       {
73481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73482       };
73483     } catch (Dali::DaliException e) {
73484       {
73485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73486       };
73487     } catch (...) {
73488       {
73489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73490       };
73491     }
73492   }
73493
73494 }
73495
73496
73497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73498   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73499   Dali::Actor arg2 ;
73500   Dali::Actor *argp2 ;
73501
73502   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73503   argp2 = (Dali::Actor *)jarg2;
73504   if (!argp2) {
73505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73506     return ;
73507   }
73508   arg2 = *argp2;
73509   {
73510     try {
73511       (arg1)->SetScrollIndicator(arg2);
73512     } catch (std::out_of_range& e) {
73513       {
73514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73515       };
73516     } catch (std::exception& e) {
73517       {
73518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73519       };
73520     } catch (Dali::DaliException e) {
73521       {
73522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73523       };
73524     } catch (...) {
73525       {
73526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73527       };
73528     }
73529   }
73530
73531 }
73532
73533
73534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73535   void * jresult ;
73536   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73537   Dali::Actor result;
73538
73539   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73540   {
73541     try {
73542       result = (arg1)->GetScrollIndicator();
73543     } catch (std::out_of_range& e) {
73544       {
73545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73546       };
73547     } catch (std::exception& e) {
73548       {
73549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73550       };
73551     } catch (Dali::DaliException e) {
73552       {
73553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73554       };
73555     } catch (...) {
73556       {
73557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73558       };
73559     }
73560   }
73561
73562   jresult = new Dali::Actor((const Dali::Actor &)result);
73563   return jresult;
73564 }
73565
73566
73567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73568   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73569   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73570
73571   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73572   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73573   if (!arg2) {
73574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73575     return ;
73576   }
73577   {
73578     try {
73579       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73580     } catch (std::out_of_range& e) {
73581       {
73582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73583       };
73584     } catch (std::exception& e) {
73585       {
73586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73587       };
73588     } catch (Dali::DaliException e) {
73589       {
73590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73591       };
73592     } catch (...) {
73593       {
73594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73595       };
73596     }
73597   }
73598
73599 }
73600
73601
73602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73603   void * jresult ;
73604   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73605
73606   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73607   {
73608     try {
73609       jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)(((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals()));
73610     } catch (std::out_of_range& e) {
73611       {
73612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73613       };
73614     } catch (std::exception& e) {
73615       {
73616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73617       };
73618     } catch (...) {
73619       {
73620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73621       };
73622     }
73623   }
73624   return jresult;
73625 }
73626
73627
73628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73629   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73630   Dali::Toolkit::ScrollBar::Direction arg2 ;
73631
73632   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73633   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73634   {
73635     try {
73636       (arg1)->SetScrollDirection(arg2);
73637     } catch (std::out_of_range& e) {
73638       {
73639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73640       };
73641     } catch (std::exception& e) {
73642       {
73643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73644       };
73645     } catch (Dali::DaliException e) {
73646       {
73647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73648       };
73649     } catch (...) {
73650       {
73651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73652       };
73653     }
73654   }
73655
73656 }
73657
73658
73659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73660   int jresult ;
73661   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73662   Dali::Toolkit::ScrollBar::Direction result;
73663
73664   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73665   {
73666     try {
73667       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73668     } catch (std::out_of_range& e) {
73669       {
73670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73671       };
73672     } catch (std::exception& e) {
73673       {
73674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73675       };
73676     } catch (Dali::DaliException e) {
73677       {
73678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73679       };
73680     } catch (...) {
73681       {
73682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73683       };
73684     }
73685   }
73686
73687   jresult = (int)result;
73688   return jresult;
73689 }
73690
73691
73692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73693   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73694   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73695
73696   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73697   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73698   {
73699     try {
73700       (arg1)->SetIndicatorHeightPolicy(arg2);
73701     } catch (std::out_of_range& e) {
73702       {
73703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73704       };
73705     } catch (std::exception& e) {
73706       {
73707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73708       };
73709     } catch (Dali::DaliException e) {
73710       {
73711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73712       };
73713     } catch (...) {
73714       {
73715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73716       };
73717     }
73718   }
73719
73720 }
73721
73722
73723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73724   int jresult ;
73725   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73726   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73727
73728   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73729   {
73730     try {
73731       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73732     } catch (std::out_of_range& e) {
73733       {
73734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73735       };
73736     } catch (std::exception& e) {
73737       {
73738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73739       };
73740     } catch (Dali::DaliException e) {
73741       {
73742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73743       };
73744     } catch (...) {
73745       {
73746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73747       };
73748     }
73749   }
73750
73751   jresult = (int)result;
73752   return jresult;
73753 }
73754
73755
73756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73757   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73758   float arg2 ;
73759
73760   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73761   arg2 = (float)jarg2;
73762   {
73763     try {
73764       (arg1)->SetIndicatorFixedHeight(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 (Dali::DaliException e) {
73774       {
73775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73776       };
73777     } catch (...) {
73778       {
73779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73780       };
73781     }
73782   }
73783
73784 }
73785
73786
73787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73788   float jresult ;
73789   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73790   float result;
73791
73792   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73793   {
73794     try {
73795       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73796     } catch (std::out_of_range& e) {
73797       {
73798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73799       };
73800     } catch (std::exception& e) {
73801       {
73802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73803       };
73804     } catch (Dali::DaliException e) {
73805       {
73806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73807       };
73808     } catch (...) {
73809       {
73810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73811       };
73812     }
73813   }
73814
73815   jresult = result;
73816   return jresult;
73817 }
73818
73819
73820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73821   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73822   float arg2 ;
73823
73824   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73825   arg2 = (float)jarg2;
73826   {
73827     try {
73828       (arg1)->SetIndicatorShowDuration(arg2);
73829     } catch (std::out_of_range& e) {
73830       {
73831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73832       };
73833     } catch (std::exception& e) {
73834       {
73835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73836       };
73837     } catch (Dali::DaliException e) {
73838       {
73839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73840       };
73841     } catch (...) {
73842       {
73843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73844       };
73845     }
73846   }
73847
73848 }
73849
73850
73851 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73852   float jresult ;
73853   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73854   float result;
73855
73856   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73857   {
73858     try {
73859       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73860     } catch (std::out_of_range& e) {
73861       {
73862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73863       };
73864     } catch (std::exception& e) {
73865       {
73866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73867       };
73868     } catch (Dali::DaliException e) {
73869       {
73870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73871       };
73872     } catch (...) {
73873       {
73874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73875       };
73876     }
73877   }
73878
73879   jresult = result;
73880   return jresult;
73881 }
73882
73883
73884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73885   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73886   float arg2 ;
73887
73888   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73889   arg2 = (float)jarg2;
73890   {
73891     try {
73892       (arg1)->SetIndicatorHideDuration(arg2);
73893     } catch (std::out_of_range& e) {
73894       {
73895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73896       };
73897     } catch (std::exception& e) {
73898       {
73899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73900       };
73901     } catch (Dali::DaliException e) {
73902       {
73903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73904       };
73905     } catch (...) {
73906       {
73907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73908       };
73909     }
73910   }
73911
73912 }
73913
73914
73915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73916   float jresult ;
73917   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73918   float result;
73919
73920   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73921   {
73922     try {
73923       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73924     } catch (std::out_of_range& e) {
73925       {
73926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73927       };
73928     } catch (std::exception& e) {
73929       {
73930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73931       };
73932     } catch (Dali::DaliException e) {
73933       {
73934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73935       };
73936     } catch (...) {
73937       {
73938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73939       };
73940     }
73941   }
73942
73943   jresult = result;
73944   return jresult;
73945 }
73946
73947
73948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73949   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73950
73951   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73952   {
73953     try {
73954       (arg1)->ShowIndicator();
73955     } catch (std::out_of_range& e) {
73956       {
73957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73958       };
73959     } catch (std::exception& e) {
73960       {
73961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73962       };
73963     } catch (Dali::DaliException e) {
73964       {
73965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73966       };
73967     } catch (...) {
73968       {
73969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73970       };
73971     }
73972   }
73973
73974 }
73975
73976
73977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73978   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73979
73980   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73981   {
73982     try {
73983       (arg1)->HideIndicator();
73984     } catch (std::out_of_range& e) {
73985       {
73986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73987       };
73988     } catch (std::exception& e) {
73989       {
73990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73991       };
73992     } catch (Dali::DaliException e) {
73993       {
73994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73995       };
73996     } catch (...) {
73997       {
73998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73999       };
74000     }
74001   }
74002
74003 }
74004
74005
74006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
74007   void * jresult ;
74008   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74009   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74010
74011   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74012   {
74013     try {
74014       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74015     } catch (std::out_of_range& e) {
74016       {
74017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74018       };
74019     } catch (std::exception& e) {
74020       {
74021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74022       };
74023     } catch (Dali::DaliException e) {
74024       {
74025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74026       };
74027     } catch (...) {
74028       {
74029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74030       };
74031     }
74032   }
74033
74034   jresult = (void *)result;
74035   return jresult;
74036 }
74037
74038
74039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74040   void * jresult ;
74041   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74042   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74043
74044   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74045   {
74046     try {
74047       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74048     } catch (std::out_of_range& e) {
74049       {
74050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74051       };
74052     } catch (std::exception& e) {
74053       {
74054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74055       };
74056     } catch (Dali::DaliException e) {
74057       {
74058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74059       };
74060     } catch (...) {
74061       {
74062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74063       };
74064     }
74065   }
74066
74067   jresult = (void *)result;
74068   return jresult;
74069 }
74070
74071
74072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74073   int jresult ;
74074   int result;
74075
74076   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74077   jresult = (int)result;
74078   return jresult;
74079 }
74080
74081
74082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74083   int jresult ;
74084   int result;
74085
74086   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74087   jresult = (int)result;
74088   return jresult;
74089 }
74090
74091
74092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74093   int jresult ;
74094   int result;
74095
74096   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74097   jresult = (int)result;
74098   return jresult;
74099 }
74100
74101
74102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74103   int jresult ;
74104   int result;
74105
74106   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74107   jresult = (int)result;
74108   return jresult;
74109 }
74110
74111
74112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74113   int jresult ;
74114   int result;
74115
74116   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74117   jresult = (int)result;
74118   return jresult;
74119 }
74120
74121
74122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74123   int jresult ;
74124   int result;
74125
74126   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74127   jresult = (int)result;
74128   return jresult;
74129 }
74130
74131
74132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74133   int jresult ;
74134   int result;
74135
74136   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74137   jresult = (int)result;
74138   return jresult;
74139 }
74140
74141
74142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74143   int jresult ;
74144   int result;
74145
74146   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74147   jresult = (int)result;
74148   return jresult;
74149 }
74150
74151
74152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74153   int jresult ;
74154   int result;
74155
74156   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74157   jresult = (int)result;
74158   return jresult;
74159 }
74160
74161
74162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74163   int jresult ;
74164   int result;
74165
74166   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74167   jresult = (int)result;
74168   return jresult;
74169 }
74170
74171
74172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74173   int jresult ;
74174   int result;
74175
74176   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74177   jresult = (int)result;
74178   return jresult;
74179 }
74180
74181
74182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74183   int jresult ;
74184   int result;
74185
74186   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74187   jresult = (int)result;
74188   return jresult;
74189 }
74190
74191
74192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74193   int jresult ;
74194   int result;
74195
74196   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74197   jresult = (int)result;
74198   return jresult;
74199 }
74200
74201
74202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74203   int jresult ;
74204   int result;
74205
74206   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74207   jresult = (int)result;
74208   return jresult;
74209 }
74210
74211
74212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74213   void * jresult ;
74214   Dali::Toolkit::Scrollable::Property *result = 0 ;
74215
74216   {
74217     try {
74218       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
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 (Dali::DaliException e) {
74228       {
74229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74230       };
74231     } catch (...) {
74232       {
74233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74234       };
74235     }
74236   }
74237
74238   jresult = (void *)result;
74239   return jresult;
74240 }
74241
74242
74243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74244   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74245
74246   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74247   {
74248     try {
74249       delete arg1;
74250     } catch (std::out_of_range& e) {
74251       {
74252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74253       };
74254     } catch (std::exception& e) {
74255       {
74256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74257       };
74258     } catch (Dali::DaliException e) {
74259       {
74260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74261       };
74262     } catch (...) {
74263       {
74264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74265       };
74266     }
74267   }
74268
74269 }
74270
74271
74272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74273   void * jresult ;
74274   Dali::Toolkit::Scrollable *result = 0 ;
74275
74276   {
74277     try {
74278       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74279     } catch (std::out_of_range& e) {
74280       {
74281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74282       };
74283     } catch (std::exception& e) {
74284       {
74285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74286       };
74287     } catch (Dali::DaliException e) {
74288       {
74289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74290       };
74291     } catch (...) {
74292       {
74293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74294       };
74295     }
74296   }
74297
74298   jresult = (void *)result;
74299   return jresult;
74300 }
74301
74302
74303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74304   void * jresult ;
74305   Dali::Toolkit::Scrollable *arg1 = 0 ;
74306   Dali::Toolkit::Scrollable *result = 0 ;
74307
74308   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74309   if (!arg1) {
74310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74311     return 0;
74312   }
74313   {
74314     try {
74315       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74316     } catch (std::out_of_range& e) {
74317       {
74318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74319       };
74320     } catch (std::exception& e) {
74321       {
74322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74323       };
74324     } catch (Dali::DaliException e) {
74325       {
74326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74327       };
74328     } catch (...) {
74329       {
74330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74331       };
74332     }
74333   }
74334
74335   jresult = (void *)result;
74336   return jresult;
74337 }
74338
74339
74340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74341   void * jresult ;
74342   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74343   Dali::Toolkit::Scrollable *arg2 = 0 ;
74344   Dali::Toolkit::Scrollable *result = 0 ;
74345
74346   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74347   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74348   if (!arg2) {
74349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74350     return 0;
74351   }
74352   {
74353     try {
74354       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74355     } catch (std::out_of_range& e) {
74356       {
74357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74358       };
74359     } catch (std::exception& e) {
74360       {
74361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74362       };
74363     } catch (Dali::DaliException e) {
74364       {
74365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74366       };
74367     } catch (...) {
74368       {
74369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74370       };
74371     }
74372   }
74373
74374   jresult = (void *)result;
74375   return jresult;
74376 }
74377
74378
74379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74380   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74381
74382   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74383   {
74384     try {
74385       delete arg1;
74386     } catch (std::out_of_range& e) {
74387       {
74388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74389       };
74390     } catch (std::exception& e) {
74391       {
74392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74393       };
74394     } catch (Dali::DaliException e) {
74395       {
74396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74397       };
74398     } catch (...) {
74399       {
74400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74401       };
74402     }
74403   }
74404
74405 }
74406
74407
74408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74409   void * jresult ;
74410   Dali::BaseHandle arg1 ;
74411   Dali::BaseHandle *argp1 ;
74412   Dali::Toolkit::Scrollable result;
74413
74414   argp1 = (Dali::BaseHandle *)jarg1;
74415   if (!argp1) {
74416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74417     return 0;
74418   }
74419   arg1 = *argp1;
74420   {
74421     try {
74422       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74423     } catch (std::out_of_range& e) {
74424       {
74425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74426       };
74427     } catch (std::exception& e) {
74428       {
74429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74430       };
74431     } catch (Dali::DaliException e) {
74432       {
74433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74434       };
74435     } catch (...) {
74436       {
74437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74438       };
74439     }
74440   }
74441
74442   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74443   return jresult;
74444 }
74445
74446
74447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74448   unsigned int jresult ;
74449   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74450   bool result;
74451
74452   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74453   {
74454     try {
74455       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74456     } catch (std::out_of_range& e) {
74457       {
74458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74459       };
74460     } catch (std::exception& e) {
74461       {
74462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74463       };
74464     } catch (Dali::DaliException e) {
74465       {
74466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74467       };
74468     } catch (...) {
74469       {
74470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74471       };
74472     }
74473   }
74474
74475   jresult = result;
74476   return jresult;
74477 }
74478
74479
74480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74481   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74482   bool arg2 ;
74483
74484   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74485   arg2 = jarg2 ? true : false;
74486   {
74487     try {
74488       (arg1)->SetOvershootEnabled(arg2);
74489     } catch (std::out_of_range& e) {
74490       {
74491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74492       };
74493     } catch (std::exception& e) {
74494       {
74495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74496       };
74497     } catch (Dali::DaliException e) {
74498       {
74499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74500       };
74501     } catch (...) {
74502       {
74503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74504       };
74505     }
74506   }
74507
74508 }
74509
74510
74511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74512   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74513   Dali::Vector4 *arg2 = 0 ;
74514
74515   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74516   arg2 = (Dali::Vector4 *)jarg2;
74517   if (!arg2) {
74518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74519     return ;
74520   }
74521   {
74522     try {
74523       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74524     } catch (std::out_of_range& e) {
74525       {
74526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74527       };
74528     } catch (std::exception& e) {
74529       {
74530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74531       };
74532     } catch (Dali::DaliException e) {
74533       {
74534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74535       };
74536     } catch (...) {
74537       {
74538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74539       };
74540     }
74541   }
74542
74543 }
74544
74545
74546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74547   void * jresult ;
74548   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74549   Dali::Vector4 result;
74550
74551   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74552   {
74553     try {
74554       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
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 (Dali::DaliException e) {
74564       {
74565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74566       };
74567     } catch (...) {
74568       {
74569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74570       };
74571     }
74572   }
74573
74574   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74575   return jresult;
74576 }
74577
74578
74579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74580   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74581   float arg2 ;
74582
74583   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74584   arg2 = (float)jarg2;
74585   {
74586     try {
74587       (arg1)->SetOvershootAnimationSpeed(arg2);
74588     } catch (std::out_of_range& e) {
74589       {
74590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74591       };
74592     } catch (std::exception& e) {
74593       {
74594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74595       };
74596     } catch (Dali::DaliException e) {
74597       {
74598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74599       };
74600     } catch (...) {
74601       {
74602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74603       };
74604     }
74605   }
74606
74607 }
74608
74609
74610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74611   float jresult ;
74612   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74613   float result;
74614
74615   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74616   {
74617     try {
74618       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74619     } catch (std::out_of_range& e) {
74620       {
74621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74622       };
74623     } catch (std::exception& e) {
74624       {
74625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74626       };
74627     } catch (Dali::DaliException e) {
74628       {
74629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74630       };
74631     } catch (...) {
74632       {
74633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74634       };
74635     }
74636   }
74637
74638   jresult = result;
74639   return jresult;
74640 }
74641
74642
74643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74644   void * jresult ;
74645   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74646   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74647
74648   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74649   {
74650     try {
74651       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74652     } catch (std::out_of_range& e) {
74653       {
74654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74655       };
74656     } catch (std::exception& e) {
74657       {
74658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74659       };
74660     } catch (Dali::DaliException e) {
74661       {
74662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74663       };
74664     } catch (...) {
74665       {
74666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74667       };
74668     }
74669   }
74670
74671   jresult = (void *)result;
74672   return jresult;
74673 }
74674
74675
74676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74677   void * jresult ;
74678   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74679   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74680
74681   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74682   {
74683     try {
74684       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74685     } catch (std::out_of_range& e) {
74686       {
74687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74688       };
74689     } catch (std::exception& e) {
74690       {
74691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74692       };
74693     } catch (Dali::DaliException e) {
74694       {
74695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74696       };
74697     } catch (...) {
74698       {
74699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74700       };
74701     }
74702   }
74703
74704   jresult = (void *)result;
74705   return jresult;
74706 }
74707
74708
74709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74710   void * jresult ;
74711   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74712   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74713
74714   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74715   {
74716     try {
74717       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74718     } catch (std::out_of_range& e) {
74719       {
74720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74721       };
74722     } catch (std::exception& e) {
74723       {
74724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74725       };
74726     } catch (Dali::DaliException e) {
74727       {
74728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74729       };
74730     } catch (...) {
74731       {
74732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74733       };
74734     }
74735   }
74736
74737   jresult = (void *)result;
74738   return jresult;
74739 }
74740
74741
74742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74743   unsigned int jresult ;
74744   Dali::Toolkit::ControlOrientation::Type arg1 ;
74745   bool result;
74746
74747   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74748   {
74749     try {
74750       result = (bool)Dali::Toolkit::IsVertical(arg1);
74751     } catch (std::out_of_range& e) {
74752       {
74753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74754       };
74755     } catch (std::exception& e) {
74756       {
74757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74758       };
74759     } catch (Dali::DaliException e) {
74760       {
74761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74762       };
74763     } catch (...) {
74764       {
74765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74766       };
74767     }
74768   }
74769
74770   jresult = result;
74771   return jresult;
74772 }
74773
74774
74775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74776   unsigned int jresult ;
74777   Dali::Toolkit::ControlOrientation::Type arg1 ;
74778   bool result;
74779
74780   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74781   {
74782     try {
74783       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74784     } catch (std::out_of_range& e) {
74785       {
74786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74787       };
74788     } catch (std::exception& e) {
74789       {
74790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74791       };
74792     } catch (Dali::DaliException e) {
74793       {
74794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74795       };
74796     } catch (...) {
74797       {
74798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74799       };
74800     }
74801   }
74802
74803   jresult = result;
74804   return jresult;
74805 }
74806
74807
74808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74809   void * jresult ;
74810   unsigned int arg1 ;
74811   unsigned int arg2 ;
74812   Dali::Toolkit::ItemRange *result = 0 ;
74813
74814   arg1 = (unsigned int)jarg1;
74815   arg2 = (unsigned int)jarg2;
74816   {
74817     try {
74818       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74819     } catch (std::out_of_range& e) {
74820       {
74821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74822       };
74823     } catch (std::exception& e) {
74824       {
74825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74826       };
74827     } catch (Dali::DaliException e) {
74828       {
74829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74830       };
74831     } catch (...) {
74832       {
74833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74834       };
74835     }
74836   }
74837
74838   jresult = (void *)result;
74839   return jresult;
74840 }
74841
74842
74843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74844   void * jresult ;
74845   Dali::Toolkit::ItemRange *arg1 = 0 ;
74846   Dali::Toolkit::ItemRange *result = 0 ;
74847
74848   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74849   if (!arg1) {
74850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74851     return 0;
74852   }
74853   {
74854     try {
74855       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74856     } catch (std::out_of_range& e) {
74857       {
74858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74859       };
74860     } catch (std::exception& e) {
74861       {
74862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74863       };
74864     } catch (Dali::DaliException e) {
74865       {
74866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74867       };
74868     } catch (...) {
74869       {
74870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74871       };
74872     }
74873   }
74874
74875   jresult = (void *)result;
74876   return jresult;
74877 }
74878
74879
74880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74881   void * jresult ;
74882   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74883   Dali::Toolkit::ItemRange *arg2 = 0 ;
74884   Dali::Toolkit::ItemRange *result = 0 ;
74885
74886   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74887   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74888   if (!arg2) {
74889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74890     return 0;
74891   }
74892   {
74893     try {
74894       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74895     } catch (std::out_of_range& e) {
74896       {
74897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74898       };
74899     } catch (std::exception& e) {
74900       {
74901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74902       };
74903     } catch (Dali::DaliException e) {
74904       {
74905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74906       };
74907     } catch (...) {
74908       {
74909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74910       };
74911     }
74912   }
74913
74914   jresult = (void *)result;
74915   return jresult;
74916 }
74917
74918
74919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74920   unsigned int jresult ;
74921   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74922   unsigned int arg2 ;
74923   bool result;
74924
74925   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74926   arg2 = (unsigned int)jarg2;
74927   {
74928     try {
74929       result = (bool)(arg1)->Within(arg2);
74930     } catch (std::out_of_range& e) {
74931       {
74932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74933       };
74934     } catch (std::exception& e) {
74935       {
74936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74937       };
74938     } catch (Dali::DaliException e) {
74939       {
74940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74941       };
74942     } catch (...) {
74943       {
74944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74945       };
74946     }
74947   }
74948
74949   jresult = result;
74950   return jresult;
74951 }
74952
74953
74954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74955   void * jresult ;
74956   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74957   Dali::Toolkit::ItemRange *arg2 = 0 ;
74958   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74959
74960   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74961   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74962   if (!arg2) {
74963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74964     return 0;
74965   }
74966   {
74967     try {
74968       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74969     } catch (std::out_of_range& e) {
74970       {
74971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74972       };
74973     } catch (std::exception& e) {
74974       {
74975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74976       };
74977     } catch (Dali::DaliException e) {
74978       {
74979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74980       };
74981     } catch (...) {
74982       {
74983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74984       };
74985     }
74986   }
74987
74988   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74989   return jresult;
74990 }
74991
74992
74993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74994   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74995   unsigned int arg2 ;
74996
74997   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74998   arg2 = (unsigned int)jarg2;
74999   if (arg1) (arg1)->begin = arg2;
75000 }
75001
75002
75003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
75004   unsigned int jresult ;
75005   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75006   unsigned int result;
75007
75008   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75009   result = (unsigned int) ((arg1)->begin);
75010   jresult = result;
75011   return jresult;
75012 }
75013
75014
75015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75016   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75017   unsigned int arg2 ;
75018
75019   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75020   arg2 = (unsigned int)jarg2;
75021   if (arg1) (arg1)->end = arg2;
75022 }
75023
75024
75025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75026   unsigned int jresult ;
75027   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75028   unsigned int result;
75029
75030   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75031   result = (unsigned int) ((arg1)->end);
75032   jresult = result;
75033   return jresult;
75034 }
75035
75036
75037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75038   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75039
75040   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75041   {
75042     try {
75043       delete arg1;
75044     } catch (std::out_of_range& e) {
75045       {
75046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75047       };
75048     } catch (std::exception& e) {
75049       {
75050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75051       };
75052     } catch (Dali::DaliException e) {
75053       {
75054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75055       };
75056     } catch (...) {
75057       {
75058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75059       };
75060     }
75061   }
75062
75063 }
75064
75065
75066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75067   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75068
75069   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75070   {
75071     try {
75072       delete arg1;
75073     } catch (std::out_of_range& e) {
75074       {
75075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75076       };
75077     } catch (std::exception& e) {
75078       {
75079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75080       };
75081     } catch (Dali::DaliException e) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75084       };
75085     } catch (...) {
75086       {
75087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75088       };
75089     }
75090   }
75091
75092 }
75093
75094
75095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75096   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75097   Dali::Toolkit::ControlOrientation::Type arg2 ;
75098
75099   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75100   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75101   {
75102     try {
75103       (arg1)->SetOrientation(arg2);
75104     } catch (std::out_of_range& e) {
75105       {
75106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75107       };
75108     } catch (std::exception& e) {
75109       {
75110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75111       };
75112     } catch (Dali::DaliException e) {
75113       {
75114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75115       };
75116     } catch (...) {
75117       {
75118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75119       };
75120     }
75121   }
75122
75123 }
75124
75125
75126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75127   int jresult ;
75128   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75129   Dali::Toolkit::ControlOrientation::Type result;
75130
75131   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75132   {
75133     try {
75134       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75135     } catch (std::out_of_range& e) {
75136       {
75137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75138       };
75139     } catch (std::exception& e) {
75140       {
75141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75142       };
75143     } catch (Dali::DaliException e) {
75144       {
75145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75146       };
75147     } catch (...) {
75148       {
75149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75150       };
75151     }
75152   }
75153
75154   jresult = (int)result;
75155   return jresult;
75156 }
75157
75158
75159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75160   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75161   Dali::Property::Map *arg2 = 0 ;
75162
75163   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75164   arg2 = (Dali::Property::Map *)jarg2;
75165   if (!arg2) {
75166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75167     return ;
75168   }
75169   {
75170     try {
75171       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75172     } catch (std::out_of_range& e) {
75173       {
75174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75175       };
75176     } catch (std::exception& e) {
75177       {
75178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75179       };
75180     } catch (Dali::DaliException e) {
75181       {
75182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75183       };
75184     } catch (...) {
75185       {
75186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75187       };
75188     }
75189   }
75190
75191 }
75192
75193
75194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75195   void * jresult ;
75196   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75197   Dali::Property::Map result;
75198
75199   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75200   {
75201     try {
75202       result = (arg1)->GetLayoutProperties();
75203     } catch (std::out_of_range& e) {
75204       {
75205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75206       };
75207     } catch (std::exception& e) {
75208       {
75209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75210       };
75211     } catch (Dali::DaliException e) {
75212       {
75213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75214       };
75215     } catch (...) {
75216       {
75217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75218       };
75219     }
75220   }
75221
75222   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75223   return jresult;
75224 }
75225
75226
75227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75228   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75229   unsigned int arg2 ;
75230   Dali::Vector3 *arg3 = 0 ;
75231   Dali::Vector3 *arg4 = 0 ;
75232
75233   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75234   arg2 = (unsigned int)jarg2;
75235   arg3 = (Dali::Vector3 *)jarg3;
75236   if (!arg3) {
75237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75238     return ;
75239   }
75240   arg4 = (Dali::Vector3 *)jarg4;
75241   if (!arg4) {
75242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75243     return ;
75244   }
75245   {
75246     try {
75247       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75248     } catch (std::out_of_range& e) {
75249       {
75250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75251       };
75252     } catch (std::exception& e) {
75253       {
75254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75255       };
75256     } catch (Dali::DaliException e) {
75257       {
75258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75259       };
75260     } catch (...) {
75261       {
75262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75263       };
75264     }
75265   }
75266
75267 }
75268
75269
75270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75271   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75272   Dali::Vector3 *arg2 = 0 ;
75273
75274   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75275   arg2 = (Dali::Vector3 *)jarg2;
75276   if (!arg2) {
75277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75278     return ;
75279   }
75280   {
75281     try {
75282       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75283     } catch (std::out_of_range& e) {
75284       {
75285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75286       };
75287     } catch (std::exception& e) {
75288       {
75289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75290       };
75291     } catch (Dali::DaliException e) {
75292       {
75293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75294       };
75295     } catch (...) {
75296       {
75297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75298       };
75299     }
75300   }
75301
75302 }
75303
75304
75305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75306   float jresult ;
75307   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75308   unsigned int arg2 ;
75309   Dali::Vector3 arg3 ;
75310   Dali::Vector3 *argp3 ;
75311   float result;
75312
75313   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75314   arg2 = (unsigned int)jarg2;
75315   argp3 = (Dali::Vector3 *)jarg3;
75316   if (!argp3) {
75317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75318     return 0;
75319   }
75320   arg3 = *argp3;
75321   {
75322     try {
75323       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75324     } catch (std::out_of_range& e) {
75325       {
75326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75327       };
75328     } catch (std::exception& e) {
75329       {
75330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75331       };
75332     } catch (Dali::DaliException e) {
75333       {
75334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75335       };
75336     } catch (...) {
75337       {
75338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75339       };
75340     }
75341   }
75342
75343   jresult = result;
75344   return jresult;
75345 }
75346
75347
75348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75349   float jresult ;
75350   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75351   float arg2 ;
75352   float result;
75353
75354   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75355   arg2 = (float)jarg2;
75356   {
75357     try {
75358       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75359     } catch (std::out_of_range& e) {
75360       {
75361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75362       };
75363     } catch (std::exception& e) {
75364       {
75365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75366       };
75367     } catch (Dali::DaliException e) {
75368       {
75369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75370       };
75371     } catch (...) {
75372       {
75373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75374       };
75375     }
75376   }
75377
75378   jresult = result;
75379   return jresult;
75380 }
75381
75382
75383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75384   float jresult ;
75385   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75386   unsigned int arg2 ;
75387   float result;
75388
75389   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75390   arg2 = (unsigned int)jarg2;
75391   {
75392     try {
75393       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75394     } catch (std::out_of_range& e) {
75395       {
75396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75397       };
75398     } catch (std::exception& e) {
75399       {
75400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75401       };
75402     } catch (Dali::DaliException e) {
75403       {
75404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75405       };
75406     } catch (...) {
75407       {
75408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75409       };
75410     }
75411   }
75412
75413   jresult = result;
75414   return jresult;
75415 }
75416
75417
75418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75419   void * jresult ;
75420   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75421   float arg2 ;
75422   Dali::Vector3 arg3 ;
75423   Dali::Vector3 *argp3 ;
75424   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75425
75426   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75427   arg2 = (float)jarg2;
75428   argp3 = (Dali::Vector3 *)jarg3;
75429   if (!argp3) {
75430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75431     return 0;
75432   }
75433   arg3 = *argp3;
75434   {
75435     try {
75436       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75437     } catch (std::out_of_range& e) {
75438       {
75439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75440       };
75441     } catch (std::exception& e) {
75442       {
75443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75444       };
75445     } catch (Dali::DaliException e) {
75446       {
75447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75448       };
75449     } catch (...) {
75450       {
75451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75452       };
75453     }
75454   }
75455
75456   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75457   return jresult;
75458 }
75459
75460
75461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75462   float jresult ;
75463   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75464   int arg2 ;
75465   float arg3 ;
75466   Dali::Vector3 *arg4 = 0 ;
75467   float result;
75468
75469   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75470   arg2 = (int)jarg2;
75471   arg3 = (float)jarg3;
75472   arg4 = (Dali::Vector3 *)jarg4;
75473   if (!arg4) {
75474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75475     return 0;
75476   }
75477   {
75478     try {
75479       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75480     } catch (std::out_of_range& e) {
75481       {
75482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75483       };
75484     } catch (std::exception& e) {
75485       {
75486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75487       };
75488     } catch (Dali::DaliException e) {
75489       {
75490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75491       };
75492     } catch (...) {
75493       {
75494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75495       };
75496     }
75497   }
75498
75499   jresult = result;
75500   return jresult;
75501 }
75502
75503
75504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75505   unsigned int jresult ;
75506   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75507   Dali::Vector3 arg2 ;
75508   Dali::Vector3 *argp2 ;
75509   unsigned int result;
75510
75511   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75512   argp2 = (Dali::Vector3 *)jarg2;
75513   if (!argp2) {
75514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75515     return 0;
75516   }
75517   arg2 = *argp2;
75518   {
75519     try {
75520       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75521     } catch (std::out_of_range& e) {
75522       {
75523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75524       };
75525     } catch (std::exception& e) {
75526       {
75527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75528       };
75529     } catch (Dali::DaliException e) {
75530       {
75531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75532       };
75533     } catch (...) {
75534       {
75535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75536       };
75537     }
75538   }
75539
75540   jresult = result;
75541   return jresult;
75542 }
75543
75544
75545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75546   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75547   unsigned int arg2 ;
75548   Dali::Vector3 *arg3 = 0 ;
75549   Dali::Vector3 *arg4 = 0 ;
75550
75551   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75552   arg2 = (unsigned int)jarg2;
75553   arg3 = (Dali::Vector3 *)jarg3;
75554   if (!arg3) {
75555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75556     return ;
75557   }
75558   arg4 = (Dali::Vector3 *)jarg4;
75559   if (!arg4) {
75560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75561     return ;
75562   }
75563   {
75564     try {
75565       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75566     } catch (std::out_of_range& e) {
75567       {
75568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75569       };
75570     } catch (std::exception& e) {
75571       {
75572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75573       };
75574     } catch (Dali::DaliException e) {
75575       {
75576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75577       };
75578     } catch (...) {
75579       {
75580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75581       };
75582     }
75583   }
75584
75585 }
75586
75587
75588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75589   void * jresult ;
75590   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75591   Dali::Degree result;
75592
75593   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75594   {
75595     try {
75596       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75597     } catch (std::out_of_range& e) {
75598       {
75599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75600       };
75601     } catch (std::exception& e) {
75602       {
75603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75604       };
75605     } catch (Dali::DaliException e) {
75606       {
75607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75608       };
75609     } catch (...) {
75610       {
75611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75612       };
75613     }
75614   }
75615
75616   jresult = new Dali::Degree((const Dali::Degree &)result);
75617   return jresult;
75618 }
75619
75620
75621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75622   float jresult ;
75623   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75624   float result;
75625
75626   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75627   {
75628     try {
75629       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75630     } catch (std::out_of_range& e) {
75631       {
75632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75633       };
75634     } catch (std::exception& e) {
75635       {
75636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75637       };
75638     } catch (Dali::DaliException e) {
75639       {
75640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75641       };
75642     } catch (...) {
75643       {
75644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75645       };
75646     }
75647   }
75648
75649   jresult = result;
75650   return jresult;
75651 }
75652
75653
75654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75655   float jresult ;
75656   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75657   float result;
75658
75659   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75660   {
75661     try {
75662       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75663     } catch (std::out_of_range& e) {
75664       {
75665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75666       };
75667     } catch (std::exception& e) {
75668       {
75669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75670       };
75671     } catch (Dali::DaliException e) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75674       };
75675     } catch (...) {
75676       {
75677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75678       };
75679     }
75680   }
75681
75682   jresult = result;
75683   return jresult;
75684 }
75685
75686
75687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75688   float jresult ;
75689   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75690   float result;
75691
75692   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75693   {
75694     try {
75695       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75696     } catch (std::out_of_range& e) {
75697       {
75698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75699       };
75700     } catch (std::exception& e) {
75701       {
75702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75703       };
75704     } catch (Dali::DaliException e) {
75705       {
75706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75707       };
75708     } catch (...) {
75709       {
75710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75711       };
75712     }
75713   }
75714
75715   jresult = result;
75716   return jresult;
75717 }
75718
75719
75720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75721   int jresult ;
75722   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75723   int arg2 ;
75724   int arg3 ;
75725   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75726   bool arg5 ;
75727   int result;
75728
75729   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75730   arg2 = (int)jarg2;
75731   arg3 = (int)jarg3;
75732   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75733   arg5 = jarg5 ? true : false;
75734   {
75735     try {
75736       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75737     } catch (std::out_of_range& e) {
75738       {
75739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75740       };
75741     } catch (std::exception& e) {
75742       {
75743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75744       };
75745     } catch (Dali::DaliException e) {
75746       {
75747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75748       };
75749     } catch (...) {
75750       {
75751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75752       };
75753     }
75754   }
75755
75756   jresult = result;
75757   return jresult;
75758 }
75759
75760
75761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75762   float jresult ;
75763   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75764   float result;
75765
75766   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75767   {
75768     try {
75769       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75770     } catch (std::out_of_range& e) {
75771       {
75772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75773       };
75774     } catch (std::exception& e) {
75775       {
75776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75777       };
75778     } catch (Dali::DaliException e) {
75779       {
75780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75781       };
75782     } catch (...) {
75783       {
75784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75785       };
75786     }
75787   }
75788
75789   jresult = result;
75790   return jresult;
75791 }
75792
75793
75794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75795   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75796   Dali::Actor *arg2 = 0 ;
75797   int arg3 ;
75798   Dali::Vector3 *arg4 = 0 ;
75799   Dali::Actor *arg5 = 0 ;
75800
75801   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75802   arg2 = (Dali::Actor *)jarg2;
75803   if (!arg2) {
75804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75805     return ;
75806   }
75807   arg3 = (int)jarg3;
75808   arg4 = (Dali::Vector3 *)jarg4;
75809   if (!arg4) {
75810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75811     return ;
75812   }
75813   arg5 = (Dali::Actor *)jarg5;
75814   if (!arg5) {
75815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75816     return ;
75817   }
75818   {
75819     try {
75820       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75821     } catch (std::out_of_range& e) {
75822       {
75823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75824       };
75825     } catch (std::exception& e) {
75826       {
75827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75828       };
75829     } catch (Dali::DaliException e) {
75830       {
75831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75832       };
75833     } catch (...) {
75834       {
75835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75836       };
75837     }
75838   }
75839
75840 }
75841
75842
75843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75844   void * jresult ;
75845   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75846   int arg2 ;
75847   float arg3 ;
75848   Dali::Vector3 *arg4 = 0 ;
75849   Dali::Vector3 result;
75850
75851   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75852   arg2 = (int)jarg2;
75853   arg3 = (float)jarg3;
75854   arg4 = (Dali::Vector3 *)jarg4;
75855   if (!arg4) {
75856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75857     return 0;
75858   }
75859   {
75860     try {
75861       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75862     } catch (std::out_of_range& e) {
75863       {
75864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75865       };
75866     } catch (std::exception& e) {
75867       {
75868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75869       };
75870     } catch (Dali::DaliException e) {
75871       {
75872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75873       };
75874     } catch (...) {
75875       {
75876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75877       };
75878     }
75879   }
75880
75881   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75882   return jresult;
75883 }
75884
75885
75886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75887   void * jresult ;
75888   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75889   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75890
75891   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75892   {
75893     try {
75894       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75895     } catch (std::out_of_range& e) {
75896       {
75897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75898       };
75899     } catch (std::exception& e) {
75900       {
75901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75902       };
75903     } catch (Dali::DaliException e) {
75904       {
75905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75906       };
75907     } catch (...) {
75908       {
75909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75910       };
75911     }
75912   }
75913
75914   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75915   return jresult;
75916 }
75917
75918
75919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75920   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75921
75922   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75923   {
75924     try {
75925       delete arg1;
75926     } catch (std::out_of_range& e) {
75927       {
75928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75929       };
75930     } catch (std::exception& e) {
75931       {
75932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75933       };
75934     } catch (Dali::DaliException e) {
75935       {
75936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75937       };
75938     } catch (...) {
75939       {
75940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75941       };
75942     }
75943   }
75944
75945 }
75946
75947
75948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75949   unsigned int jresult ;
75950   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75951   unsigned int result;
75952
75953   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75954   {
75955     try {
75956       result = (unsigned int)(arg1)->GetNumberOfItems();
75957     } catch (std::out_of_range& e) {
75958       {
75959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75960       };
75961     } catch (std::exception& e) {
75962       {
75963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75964       };
75965     } catch (Dali::DaliException e) {
75966       {
75967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75968       };
75969     } catch (...) {
75970       {
75971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75972       };
75973     }
75974   }
75975
75976   jresult = result;
75977   return jresult;
75978 }
75979
75980
75981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75982   void * jresult ;
75983   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75984   unsigned int arg2 ;
75985   Dali::Actor result;
75986
75987   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75988   arg2 = (unsigned int)jarg2;
75989   {
75990     try {
75991       result = (arg1)->NewItem(arg2);
75992     } catch (std::out_of_range& e) {
75993       {
75994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75995       };
75996     } catch (std::exception& e) {
75997       {
75998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75999       };
76000     } catch (Dali::DaliException e) {
76001       {
76002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76003       };
76004     } catch (...) {
76005       {
76006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76007       };
76008     }
76009   }
76010
76011   jresult = new Dali::Actor((const Dali::Actor &)result);
76012   return jresult;
76013 }
76014
76015
76016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76017   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76018   unsigned int arg2 ;
76019   Dali::Actor arg3 ;
76020   Dali::Actor *argp3 ;
76021
76022   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76023   arg2 = (unsigned int)jarg2;
76024   argp3 = (Dali::Actor *)jarg3;
76025   if (!argp3) {
76026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76027     return ;
76028   }
76029   arg3 = *argp3;
76030   {
76031     try {
76032       (arg1)->ItemReleased(arg2,arg3);
76033     } catch (std::out_of_range& e) {
76034       {
76035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76036       };
76037     } catch (std::exception& e) {
76038       {
76039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76040       };
76041     } catch (Dali::DaliException e) {
76042       {
76043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76044       };
76045     } catch (...) {
76046       {
76047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76048       };
76049     }
76050   }
76051
76052 }
76053
76054
76055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76056   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76057   unsigned int arg2 ;
76058   Dali::Actor arg3 ;
76059   Dali::Actor *argp3 ;
76060
76061   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76062   arg2 = (unsigned int)jarg2;
76063   argp3 = (Dali::Actor *)jarg3;
76064   if (!argp3) {
76065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76066     return ;
76067   }
76068   arg3 = *argp3;
76069   {
76070     try {
76071       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76072     } catch (std::out_of_range& e) {
76073       {
76074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76075       };
76076     } catch (std::exception& e) {
76077       {
76078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76079       };
76080     } catch (Dali::DaliException e) {
76081       {
76082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76083       };
76084     } catch (...) {
76085       {
76086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76087       };
76088     }
76089   }
76090
76091 }
76092
76093
76094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76095   void * jresult ;
76096   Dali::Toolkit::ItemFactory *result = 0 ;
76097
76098   {
76099     try {
76100       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76101     } catch (std::out_of_range& e) {
76102       {
76103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76104       };
76105     } catch (std::exception& e) {
76106       {
76107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76108       };
76109     } catch (Dali::DaliException e) {
76110       {
76111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76112       };
76113     } catch (...) {
76114       {
76115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76116       };
76117     }
76118   }
76119
76120   jresult = (void *)result;
76121   return jresult;
76122 }
76123
76124
76125 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) {
76126   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76127   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76128   if (director) {
76129     director->swig_connect_director(callback0, callback1, callback2);
76130   }
76131 }
76132
76133
76134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76135   int jresult ;
76136   int result;
76137
76138   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76139   jresult = (int)result;
76140   return jresult;
76141 }
76142
76143
76144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76145   int jresult ;
76146   int result;
76147
76148   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76149   jresult = (int)result;
76150   return jresult;
76151 }
76152
76153
76154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76155   int jresult ;
76156   int result;
76157
76158   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76159   jresult = (int)result;
76160   return jresult;
76161 }
76162
76163
76164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76165   int jresult ;
76166   int result;
76167
76168   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76169   jresult = (int)result;
76170   return jresult;
76171 }
76172
76173
76174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76175   int jresult ;
76176   int result;
76177
76178   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76179   jresult = (int)result;
76180   return jresult;
76181 }
76182
76183
76184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76185   int jresult ;
76186   int result;
76187
76188   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76189   jresult = (int)result;
76190   return jresult;
76191 }
76192
76193
76194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76195   int jresult ;
76196   int result;
76197
76198   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76199   jresult = (int)result;
76200   return jresult;
76201 }
76202
76203
76204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76205   int jresult ;
76206   int result;
76207
76208   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76209   jresult = (int)result;
76210   return jresult;
76211 }
76212
76213
76214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76215   int jresult ;
76216   int result;
76217
76218   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76219   jresult = (int)result;
76220   return jresult;
76221 }
76222
76223
76224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76225   int jresult ;
76226   int result;
76227
76228   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76229   jresult = (int)result;
76230   return jresult;
76231 }
76232
76233
76234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76235   int jresult ;
76236   int result;
76237
76238   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76239   jresult = (int)result;
76240   return jresult;
76241 }
76242
76243
76244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76245   void * jresult ;
76246   Dali::Toolkit::ItemView::Property *result = 0 ;
76247
76248   {
76249     try {
76250       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76251     } catch (std::out_of_range& e) {
76252       {
76253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76254       };
76255     } catch (std::exception& e) {
76256       {
76257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76258       };
76259     } catch (Dali::DaliException e) {
76260       {
76261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76262       };
76263     } catch (...) {
76264       {
76265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76266       };
76267     }
76268   }
76269
76270   jresult = (void *)result;
76271   return jresult;
76272 }
76273
76274
76275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76276   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76277
76278   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76279   {
76280     try {
76281       delete arg1;
76282     } catch (std::out_of_range& e) {
76283       {
76284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76285       };
76286     } catch (std::exception& e) {
76287       {
76288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76289       };
76290     } catch (Dali::DaliException e) {
76291       {
76292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76293       };
76294     } catch (...) {
76295       {
76296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76297       };
76298     }
76299   }
76300
76301 }
76302
76303
76304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76305   void * jresult ;
76306   Dali::Toolkit::ItemView *result = 0 ;
76307
76308   {
76309     try {
76310       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76311     } catch (std::out_of_range& e) {
76312       {
76313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76314       };
76315     } catch (std::exception& e) {
76316       {
76317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76318       };
76319     } catch (Dali::DaliException e) {
76320       {
76321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76322       };
76323     } catch (...) {
76324       {
76325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76326       };
76327     }
76328   }
76329
76330   jresult = (void *)result;
76331   return jresult;
76332 }
76333
76334
76335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76336   void * jresult ;
76337   Dali::Toolkit::ItemView *arg1 = 0 ;
76338   Dali::Toolkit::ItemView *result = 0 ;
76339
76340   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76341   if (!arg1) {
76342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76343     return 0;
76344   }
76345   {
76346     try {
76347       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76348     } catch (std::out_of_range& e) {
76349       {
76350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76351       };
76352     } catch (std::exception& e) {
76353       {
76354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76355       };
76356     } catch (Dali::DaliException e) {
76357       {
76358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76359       };
76360     } catch (...) {
76361       {
76362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76363       };
76364     }
76365   }
76366
76367   jresult = (void *)result;
76368   return jresult;
76369 }
76370
76371
76372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76373   void * jresult ;
76374   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76375   Dali::Toolkit::ItemView *arg2 = 0 ;
76376   Dali::Toolkit::ItemView *result = 0 ;
76377
76378   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76379   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76380   if (!arg2) {
76381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76382     return 0;
76383   }
76384   {
76385     try {
76386       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76387     } catch (std::out_of_range& e) {
76388       {
76389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76390       };
76391     } catch (std::exception& e) {
76392       {
76393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76394       };
76395     } catch (Dali::DaliException e) {
76396       {
76397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76398       };
76399     } catch (...) {
76400       {
76401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76402       };
76403     }
76404   }
76405
76406   jresult = (void *)result;
76407   return jresult;
76408 }
76409
76410
76411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76412   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76413
76414   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76415   {
76416     try {
76417       delete arg1;
76418     } catch (std::out_of_range& e) {
76419       {
76420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76421       };
76422     } catch (std::exception& e) {
76423       {
76424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76425       };
76426     } catch (Dali::DaliException e) {
76427       {
76428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76429       };
76430     } catch (...) {
76431       {
76432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76433       };
76434     }
76435   }
76436
76437 }
76438
76439
76440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76441   void * jresult ;
76442   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76443   Dali::Toolkit::ItemView result;
76444
76445   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76446   if (!arg1) {
76447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76448     return 0;
76449   }
76450   {
76451     try {
76452       result = Dali::Toolkit::ItemView::New(*arg1);
76453     } catch (std::out_of_range& e) {
76454       {
76455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76456       };
76457     } catch (std::exception& e) {
76458       {
76459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76460       };
76461     } catch (Dali::DaliException e) {
76462       {
76463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76464       };
76465     } catch (...) {
76466       {
76467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76468       };
76469     }
76470   }
76471
76472   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76473   return jresult;
76474 }
76475
76476
76477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76478   void * jresult ;
76479   Dali::BaseHandle arg1 ;
76480   Dali::BaseHandle *argp1 ;
76481   Dali::Toolkit::ItemView result;
76482
76483   argp1 = (Dali::BaseHandle *)jarg1;
76484   if (!argp1) {
76485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76486     return 0;
76487   }
76488   arg1 = *argp1;
76489   {
76490     try {
76491       result = Dali::Toolkit::ItemView::DownCast(arg1);
76492     } catch (std::out_of_range& e) {
76493       {
76494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76495       };
76496     } catch (std::exception& e) {
76497       {
76498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76499       };
76500     } catch (Dali::DaliException e) {
76501       {
76502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76503       };
76504     } catch (...) {
76505       {
76506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76507       };
76508     }
76509   }
76510
76511   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76512   return jresult;
76513 }
76514
76515
76516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76517   unsigned int jresult ;
76518   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76519   unsigned int result;
76520
76521   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76522   {
76523     try {
76524       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76525     } catch (std::out_of_range& e) {
76526       {
76527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76528       };
76529     } catch (std::exception& e) {
76530       {
76531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76532       };
76533     } catch (Dali::DaliException e) {
76534       {
76535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76536       };
76537     } catch (...) {
76538       {
76539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76540       };
76541     }
76542   }
76543
76544   jresult = result;
76545   return jresult;
76546 }
76547
76548
76549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76550   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76551   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76552
76553   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76554   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76555   if (!arg2) {
76556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76557     return ;
76558   }
76559   {
76560     try {
76561       (arg1)->AddLayout(*arg2);
76562     } catch (std::out_of_range& e) {
76563       {
76564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76565       };
76566     } catch (std::exception& e) {
76567       {
76568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76569       };
76570     } catch (Dali::DaliException e) {
76571       {
76572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76573       };
76574     } catch (...) {
76575       {
76576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76577       };
76578     }
76579   }
76580
76581 }
76582
76583
76584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76585   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76586   unsigned int arg2 ;
76587
76588   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76589   arg2 = (unsigned int)jarg2;
76590   {
76591     try {
76592       (arg1)->RemoveLayout(arg2);
76593     } catch (std::out_of_range& e) {
76594       {
76595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76596       };
76597     } catch (std::exception& e) {
76598       {
76599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76600       };
76601     } catch (Dali::DaliException e) {
76602       {
76603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76604       };
76605     } catch (...) {
76606       {
76607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76608       };
76609     }
76610   }
76611
76612 }
76613
76614
76615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76616   void * jresult ;
76617   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76618   unsigned int arg2 ;
76619   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76620
76621   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76622   arg2 = (unsigned int)jarg2;
76623   {
76624     try {
76625       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76626     } catch (std::out_of_range& e) {
76627       {
76628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76629       };
76630     } catch (std::exception& e) {
76631       {
76632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76633       };
76634     } catch (Dali::DaliException e) {
76635       {
76636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76637       };
76638     } catch (...) {
76639       {
76640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76641       };
76642     }
76643   }
76644
76645   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76646   return jresult;
76647 }
76648
76649
76650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76651   void * jresult ;
76652   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76653   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76654
76655   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76656   {
76657     try {
76658       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76659     } catch (std::out_of_range& e) {
76660       {
76661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76662       };
76663     } catch (std::exception& e) {
76664       {
76665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76666       };
76667     } catch (Dali::DaliException e) {
76668       {
76669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76670       };
76671     } catch (...) {
76672       {
76673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76674       };
76675     }
76676   }
76677
76678   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76679   return jresult;
76680 }
76681
76682
76683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76684   float jresult ;
76685   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76686   Dali::Toolkit::ItemId arg2 ;
76687   float result;
76688
76689   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76690   arg2 = (Dali::Toolkit::ItemId)jarg2;
76691   {
76692     try {
76693       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76694     } catch (std::out_of_range& e) {
76695       {
76696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76697       };
76698     } catch (std::exception& e) {
76699       {
76700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76701       };
76702     } catch (Dali::DaliException e) {
76703       {
76704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76705       };
76706     } catch (...) {
76707       {
76708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76709       };
76710     }
76711   }
76712
76713   jresult = result;
76714   return jresult;
76715 }
76716
76717
76718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76719   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76720   unsigned int arg2 ;
76721   Dali::Vector3 arg3 ;
76722   float arg4 ;
76723   Dali::Vector3 *argp3 ;
76724
76725   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76726   arg2 = (unsigned int)jarg2;
76727   argp3 = (Dali::Vector3 *)jarg3;
76728   if (!argp3) {
76729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76730     return ;
76731   }
76732   arg3 = *argp3;
76733   arg4 = (float)jarg4;
76734   {
76735     try {
76736       (arg1)->ActivateLayout(arg2,arg3,arg4);
76737     } catch (std::out_of_range& e) {
76738       {
76739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76740       };
76741     } catch (std::exception& e) {
76742       {
76743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76744       };
76745     } catch (Dali::DaliException e) {
76746       {
76747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76748       };
76749     } catch (...) {
76750       {
76751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76752       };
76753     }
76754   }
76755
76756 }
76757
76758
76759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76760   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76761
76762   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76763   {
76764     try {
76765       (arg1)->DeactivateCurrentLayout();
76766     } catch (std::out_of_range& e) {
76767       {
76768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76769       };
76770     } catch (std::exception& e) {
76771       {
76772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76773       };
76774     } catch (Dali::DaliException e) {
76775       {
76776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76777       };
76778     } catch (...) {
76779       {
76780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76781       };
76782     }
76783   }
76784
76785 }
76786
76787
76788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76789   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76790   float arg2 ;
76791
76792   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76793   arg2 = (float)jarg2;
76794   {
76795     try {
76796       (arg1)->SetMinimumSwipeSpeed(arg2);
76797     } catch (std::out_of_range& e) {
76798       {
76799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76800       };
76801     } catch (std::exception& e) {
76802       {
76803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76804       };
76805     } catch (Dali::DaliException e) {
76806       {
76807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76808       };
76809     } catch (...) {
76810       {
76811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76812       };
76813     }
76814   }
76815
76816 }
76817
76818
76819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76820   float jresult ;
76821   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76822   float result;
76823
76824   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76825   {
76826     try {
76827       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76828     } catch (std::out_of_range& e) {
76829       {
76830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76831       };
76832     } catch (std::exception& e) {
76833       {
76834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76835       };
76836     } catch (Dali::DaliException e) {
76837       {
76838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76839       };
76840     } catch (...) {
76841       {
76842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76843       };
76844     }
76845   }
76846
76847   jresult = result;
76848   return jresult;
76849 }
76850
76851
76852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76853   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76854   float arg2 ;
76855
76856   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76857   arg2 = (float)jarg2;
76858   {
76859     try {
76860       (arg1)->SetMinimumSwipeDistance(arg2);
76861     } catch (std::out_of_range& e) {
76862       {
76863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76864       };
76865     } catch (std::exception& e) {
76866       {
76867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76868       };
76869     } catch (Dali::DaliException e) {
76870       {
76871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76872       };
76873     } catch (...) {
76874       {
76875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76876       };
76877     }
76878   }
76879
76880 }
76881
76882
76883 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76884   float jresult ;
76885   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76886   float result;
76887
76888   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76889   {
76890     try {
76891       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76892     } catch (std::out_of_range& e) {
76893       {
76894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76895       };
76896     } catch (std::exception& e) {
76897       {
76898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76899       };
76900     } catch (Dali::DaliException e) {
76901       {
76902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76903       };
76904     } catch (...) {
76905       {
76906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76907       };
76908     }
76909   }
76910
76911   jresult = result;
76912   return jresult;
76913 }
76914
76915
76916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76917   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76918   float arg2 ;
76919
76920   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76921   arg2 = (float)jarg2;
76922   {
76923     try {
76924       (arg1)->SetWheelScrollDistanceStep(arg2);
76925     } catch (std::out_of_range& e) {
76926       {
76927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76928       };
76929     } catch (std::exception& e) {
76930       {
76931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76932       };
76933     } catch (Dali::DaliException e) {
76934       {
76935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76936       };
76937     } catch (...) {
76938       {
76939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76940       };
76941     }
76942   }
76943
76944 }
76945
76946
76947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76948   float jresult ;
76949   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76950   float result;
76951
76952   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76953   {
76954     try {
76955       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76956     } catch (std::out_of_range& e) {
76957       {
76958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76959       };
76960     } catch (std::exception& e) {
76961       {
76962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76963       };
76964     } catch (Dali::DaliException e) {
76965       {
76966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76967       };
76968     } catch (...) {
76969       {
76970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76971       };
76972     }
76973   }
76974
76975   jresult = result;
76976   return jresult;
76977 }
76978
76979
76980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76981   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76982   bool arg2 ;
76983
76984   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76985   arg2 = jarg2 ? true : false;
76986   {
76987     try {
76988       (arg1)->SetAnchoring(arg2);
76989     } catch (std::out_of_range& e) {
76990       {
76991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76992       };
76993     } catch (std::exception& e) {
76994       {
76995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76996       };
76997     } catch (Dali::DaliException e) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77000       };
77001     } catch (...) {
77002       {
77003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77004       };
77005     }
77006   }
77007
77008 }
77009
77010 //// ========================= end of part 3 =============================
77011
77012 //// ========================== start part 4 ===============================
77013
77014
77015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77016   unsigned int jresult ;
77017   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77018   bool result;
77019
77020   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77021   {
77022     try {
77023       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
77024     } catch (std::out_of_range& e) {
77025       {
77026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77027       };
77028     } catch (std::exception& e) {
77029       {
77030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77031       };
77032     } catch (Dali::DaliException e) {
77033       {
77034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77035       };
77036     } catch (...) {
77037       {
77038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77039       };
77040     }
77041   }
77042
77043   jresult = result;
77044   return jresult;
77045 }
77046
77047
77048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
77049   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77050   float arg2 ;
77051
77052   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77053   arg2 = (float)jarg2;
77054   {
77055     try {
77056       (arg1)->SetAnchoringDuration(arg2);
77057     } catch (std::out_of_range& e) {
77058       {
77059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77060       };
77061     } catch (std::exception& e) {
77062       {
77063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77064       };
77065     } catch (Dali::DaliException e) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77068       };
77069     } catch (...) {
77070       {
77071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77072       };
77073     }
77074   }
77075
77076 }
77077
77078
77079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77080   float jresult ;
77081   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77082   float result;
77083
77084   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77085   {
77086     try {
77087       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77088     } catch (std::out_of_range& e) {
77089       {
77090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77091       };
77092     } catch (std::exception& e) {
77093       {
77094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77095       };
77096     } catch (Dali::DaliException e) {
77097       {
77098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77099       };
77100     } catch (...) {
77101       {
77102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77103       };
77104     }
77105   }
77106
77107   jresult = result;
77108   return jresult;
77109 }
77110
77111
77112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77113   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77114   Dali::Toolkit::ItemId arg2 ;
77115   float arg3 ;
77116
77117   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77118   arg2 = (Dali::Toolkit::ItemId)jarg2;
77119   arg3 = (float)jarg3;
77120   {
77121     try {
77122       (arg1)->ScrollToItem(arg2,arg3);
77123     } catch (std::out_of_range& e) {
77124       {
77125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77126       };
77127     } catch (std::exception& e) {
77128       {
77129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77130       };
77131     } catch (Dali::DaliException e) {
77132       {
77133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77134       };
77135     } catch (...) {
77136       {
77137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77138       };
77139     }
77140   }
77141
77142 }
77143
77144
77145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77146   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77147   float arg2 ;
77148
77149   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77150   arg2 = (float)jarg2;
77151   {
77152     try {
77153       (arg1)->SetRefreshInterval(arg2);
77154     } catch (std::out_of_range& e) {
77155       {
77156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77157       };
77158     } catch (std::exception& e) {
77159       {
77160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77161       };
77162     } catch (Dali::DaliException e) {
77163       {
77164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77165       };
77166     } catch (...) {
77167       {
77168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77169       };
77170     }
77171   }
77172
77173 }
77174
77175
77176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77177   float jresult ;
77178   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77179   float result;
77180
77181   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77182   {
77183     try {
77184       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77185     } catch (std::out_of_range& e) {
77186       {
77187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77188       };
77189     } catch (std::exception& e) {
77190       {
77191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77192       };
77193     } catch (Dali::DaliException e) {
77194       {
77195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77196       };
77197     } catch (...) {
77198       {
77199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77200       };
77201     }
77202   }
77203
77204   jresult = result;
77205   return jresult;
77206 }
77207
77208
77209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77210   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77211
77212   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77213   {
77214     try {
77215       (arg1)->Refresh();
77216     } catch (std::out_of_range& e) {
77217       {
77218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77219       };
77220     } catch (std::exception& e) {
77221       {
77222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77223       };
77224     } catch (Dali::DaliException e) {
77225       {
77226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77227       };
77228     } catch (...) {
77229       {
77230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77231       };
77232     }
77233   }
77234
77235 }
77236
77237
77238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77239   void * jresult ;
77240   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77241   Dali::Toolkit::ItemId arg2 ;
77242   Dali::Actor result;
77243
77244   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77245   arg2 = (Dali::Toolkit::ItemId)jarg2;
77246   {
77247     try {
77248       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77249     } catch (std::out_of_range& e) {
77250       {
77251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77252       };
77253     } catch (std::exception& e) {
77254       {
77255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77256       };
77257     } catch (Dali::DaliException e) {
77258       {
77259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77260       };
77261     } catch (...) {
77262       {
77263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77264       };
77265     }
77266   }
77267
77268   jresult = new Dali::Actor((const Dali::Actor &)result);
77269   return jresult;
77270 }
77271
77272
77273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77274   unsigned int jresult ;
77275   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77276   Dali::Actor arg2 ;
77277   Dali::Actor *argp2 ;
77278   Dali::Toolkit::ItemId result;
77279
77280   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77281   argp2 = (Dali::Actor *)jarg2;
77282   if (!argp2) {
77283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77284     return 0;
77285   }
77286   arg2 = *argp2;
77287   {
77288     try {
77289       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77290     } catch (std::out_of_range& e) {
77291       {
77292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77293       };
77294     } catch (std::exception& e) {
77295       {
77296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77297       };
77298     } catch (Dali::DaliException e) {
77299       {
77300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77301       };
77302     } catch (...) {
77303       {
77304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77305       };
77306     }
77307   }
77308
77309   jresult = result;
77310   return jresult;
77311 }
77312
77313
77314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77315   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77316   Dali::Toolkit::Item arg2 ;
77317   float arg3 ;
77318   Dali::Toolkit::Item *argp2 ;
77319
77320   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77321   argp2 = (Dali::Toolkit::Item *)jarg2;
77322   if (!argp2) {
77323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77324     return ;
77325   }
77326   arg2 = *argp2;
77327   arg3 = (float)jarg3;
77328   {
77329     try {
77330       (arg1)->InsertItem(arg2,arg3);
77331     } catch (std::out_of_range& e) {
77332       {
77333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77334       };
77335     } catch (std::exception& e) {
77336       {
77337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77338       };
77339     } catch (Dali::DaliException e) {
77340       {
77341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77342       };
77343     } catch (...) {
77344       {
77345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77346       };
77347     }
77348   }
77349
77350 }
77351
77352
77353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77354   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77355   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77356   float arg3 ;
77357
77358   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77359   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77360   if (!arg2) {
77361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77362     return ;
77363   }
77364   arg3 = (float)jarg3;
77365   {
77366     try {
77367       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77368     } catch (std::out_of_range& e) {
77369       {
77370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77371       };
77372     } catch (std::exception& e) {
77373       {
77374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77375       };
77376     } catch (Dali::DaliException e) {
77377       {
77378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77379       };
77380     } catch (...) {
77381       {
77382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77383       };
77384     }
77385   }
77386
77387 }
77388
77389
77390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77391   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77392   Dali::Toolkit::ItemId arg2 ;
77393   float arg3 ;
77394
77395   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77396   arg2 = (Dali::Toolkit::ItemId)jarg2;
77397   arg3 = (float)jarg3;
77398   {
77399     try {
77400       (arg1)->RemoveItem(arg2,arg3);
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 (Dali::DaliException e) {
77410       {
77411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77412       };
77413     } catch (...) {
77414       {
77415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77416       };
77417     }
77418   }
77419
77420 }
77421
77422
77423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77424   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77425   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77426   float arg3 ;
77427
77428   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77429   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77430   if (!arg2) {
77431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77432     return ;
77433   }
77434   arg3 = (float)jarg3;
77435   {
77436     try {
77437       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77438     } catch (std::out_of_range& e) {
77439       {
77440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77441       };
77442     } catch (std::exception& e) {
77443       {
77444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77445       };
77446     } catch (Dali::DaliException e) {
77447       {
77448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77449       };
77450     } catch (...) {
77451       {
77452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77453       };
77454     }
77455   }
77456
77457 }
77458
77459
77460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77461   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77462   Dali::Toolkit::Item arg2 ;
77463   float arg3 ;
77464   Dali::Toolkit::Item *argp2 ;
77465
77466   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77467   argp2 = (Dali::Toolkit::Item *)jarg2;
77468   if (!argp2) {
77469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77470     return ;
77471   }
77472   arg2 = *argp2;
77473   arg3 = (float)jarg3;
77474   {
77475     try {
77476       (arg1)->ReplaceItem(arg2,arg3);
77477     } catch (std::out_of_range& e) {
77478       {
77479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77480       };
77481     } catch (std::exception& e) {
77482       {
77483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77484       };
77485     } catch (Dali::DaliException e) {
77486       {
77487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77488       };
77489     } catch (...) {
77490       {
77491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77492       };
77493     }
77494   }
77495
77496 }
77497
77498
77499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77500   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77501   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77502   float arg3 ;
77503
77504   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77505   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77506   if (!arg2) {
77507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77508     return ;
77509   }
77510   arg3 = (float)jarg3;
77511   {
77512     try {
77513       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77514     } catch (std::out_of_range& e) {
77515       {
77516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77517       };
77518     } catch (std::exception& e) {
77519       {
77520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77521       };
77522     } catch (Dali::DaliException e) {
77523       {
77524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77525       };
77526     } catch (...) {
77527       {
77528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77529       };
77530     }
77531   }
77532
77533 }
77534
77535
77536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77537   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77538   Dali::Vector3 *arg2 = 0 ;
77539
77540   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77541   arg2 = (Dali::Vector3 *)jarg2;
77542   if (!arg2) {
77543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77544     return ;
77545   }
77546   {
77547     try {
77548       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77549     } catch (std::out_of_range& e) {
77550       {
77551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77552       };
77553     } catch (std::exception& e) {
77554       {
77555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77556       };
77557     } catch (Dali::DaliException e) {
77558       {
77559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77560       };
77561     } catch (...) {
77562       {
77563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77564       };
77565     }
77566   }
77567
77568 }
77569
77570
77571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77572   void * jresult ;
77573   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77574   Dali::Vector3 result;
77575
77576   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77577   {
77578     try {
77579       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77580     } catch (std::out_of_range& e) {
77581       {
77582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77583       };
77584     } catch (std::exception& e) {
77585       {
77586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77587       };
77588     } catch (Dali::DaliException e) {
77589       {
77590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77591       };
77592     } catch (...) {
77593       {
77594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77595       };
77596     }
77597   }
77598
77599   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77600   return jresult;
77601 }
77602
77603
77604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77605   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77606   Dali::Vector3 *arg2 = 0 ;
77607
77608   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77609   arg2 = (Dali::Vector3 *)jarg2;
77610   if (!arg2) {
77611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77612     return ;
77613   }
77614   {
77615     try {
77616       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77617     } catch (std::out_of_range& e) {
77618       {
77619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77620       };
77621     } catch (std::exception& e) {
77622       {
77623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77624       };
77625     } catch (Dali::DaliException e) {
77626       {
77627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77628       };
77629     } catch (...) {
77630       {
77631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77632       };
77633     }
77634   }
77635
77636 }
77637
77638
77639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77640   void * jresult ;
77641   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77642   Dali::Vector3 result;
77643
77644   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77645   {
77646     try {
77647       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77648     } catch (std::out_of_range& e) {
77649       {
77650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77651       };
77652     } catch (std::exception& e) {
77653       {
77654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77655       };
77656     } catch (Dali::DaliException e) {
77657       {
77658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77659       };
77660     } catch (...) {
77661       {
77662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77663       };
77664     }
77665   }
77666
77667   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77668   return jresult;
77669 }
77670
77671
77672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77673   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77674   Dali::Toolkit::ItemRange *arg2 = 0 ;
77675
77676   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77677   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77678   if (!arg2) {
77679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77680     return ;
77681   }
77682   {
77683     try {
77684       (arg1)->GetItemsRange(*arg2);
77685     } catch (std::out_of_range& e) {
77686       {
77687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77688       };
77689     } catch (std::exception& e) {
77690       {
77691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77692       };
77693     } catch (Dali::DaliException e) {
77694       {
77695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77696       };
77697     } catch (...) {
77698       {
77699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77700       };
77701     }
77702   }
77703
77704 }
77705
77706
77707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77708   void * jresult ;
77709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77710   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77711
77712   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77713   {
77714     try {
77715       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77716     } catch (std::out_of_range& e) {
77717       {
77718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77719       };
77720     } catch (std::exception& e) {
77721       {
77722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77723       };
77724     } catch (Dali::DaliException e) {
77725       {
77726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77727       };
77728     } catch (...) {
77729       {
77730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77731       };
77732     }
77733   }
77734
77735   jresult = (void *)result;
77736   return jresult;
77737 }
77738
77739
77740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77741   Dali::Vector3 *arg1 = 0 ;
77742   PropertyInputContainer *arg2 = 0 ;
77743
77744   arg1 = (Dali::Vector3 *)jarg1;
77745   if (!arg1) {
77746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77747     return ;
77748   }
77749   arg2 = (PropertyInputContainer *)jarg2;
77750   if (!arg2) {
77751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77752     return ;
77753   }
77754   {
77755     try {
77756       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77757     } catch (std::out_of_range& e) {
77758       {
77759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77760       };
77761     } catch (std::exception& e) {
77762       {
77763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77764       };
77765     } catch (Dali::DaliException e) {
77766       {
77767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77768       };
77769     } catch (...) {
77770       {
77771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77772       };
77773     }
77774   }
77775
77776 }
77777
77778
77779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77780   Dali::Vector3 *arg1 = 0 ;
77781   PropertyInputContainer *arg2 = 0 ;
77782
77783   arg1 = (Dali::Vector3 *)jarg1;
77784   if (!arg1) {
77785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77786     return ;
77787   }
77788   arg2 = (PropertyInputContainer *)jarg2;
77789   if (!arg2) {
77790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77791     return ;
77792   }
77793   {
77794     try {
77795       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77796     } catch (std::out_of_range& e) {
77797       {
77798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77799       };
77800     } catch (std::exception& e) {
77801       {
77802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77803       };
77804     } catch (Dali::DaliException e) {
77805       {
77806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77807       };
77808     } catch (...) {
77809       {
77810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77811       };
77812     }
77813   }
77814
77815 }
77816
77817
77818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77819   void * jresult ;
77820   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77821
77822   {
77823     try {
77824       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77825     } catch (std::out_of_range& e) {
77826       {
77827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77828       };
77829     } catch (std::exception& e) {
77830       {
77831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77832       };
77833     } catch (Dali::DaliException e) {
77834       {
77835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77836       };
77837     } catch (...) {
77838       {
77839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77840       };
77841     }
77842   }
77843
77844   jresult = (void *)result;
77845   return jresult;
77846 }
77847
77848
77849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77850   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77851
77852   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77853   {
77854     try {
77855       delete arg1;
77856     } catch (std::out_of_range& e) {
77857       {
77858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77859       };
77860     } catch (std::exception& e) {
77861       {
77862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77863       };
77864     } catch (Dali::DaliException e) {
77865       {
77866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77867       };
77868     } catch (...) {
77869       {
77870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77871       };
77872     }
77873   }
77874
77875 }
77876
77877
77878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77879   void * jresult ;
77880   Dali::Path arg1 ;
77881   Dali::Vector3 *arg2 = 0 ;
77882   Dali::Property::Index arg3 ;
77883   Dali::Vector3 *arg4 = 0 ;
77884   unsigned int arg5 ;
77885   Dali::Path *argp1 ;
77886   Dali::Toolkit::ScrollViewPagePathEffect result;
77887
77888   argp1 = (Dali::Path *)jarg1;
77889   if (!argp1) {
77890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77891     return 0;
77892   }
77893   arg1 = *argp1;
77894   arg2 = (Dali::Vector3 *)jarg2;
77895   if (!arg2) {
77896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77897     return 0;
77898   }
77899   arg3 = (Dali::Property::Index)jarg3;
77900   arg4 = (Dali::Vector3 *)jarg4;
77901   if (!arg4) {
77902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77903     return 0;
77904   }
77905   arg5 = (unsigned int)jarg5;
77906   {
77907     try {
77908       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77909     } catch (std::out_of_range& e) {
77910       {
77911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77912       };
77913     } catch (std::exception& e) {
77914       {
77915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77916       };
77917     } catch (Dali::DaliException e) {
77918       {
77919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77920       };
77921     } catch (...) {
77922       {
77923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77924       };
77925     }
77926   }
77927
77928   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77929   return jresult;
77930 }
77931
77932
77933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77934   void * jresult ;
77935   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77936
77937   {
77938     try {
77939       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77940     } catch (std::out_of_range& e) {
77941       {
77942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77943       };
77944     } catch (std::exception& e) {
77945       {
77946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77947       };
77948     } catch (Dali::DaliException e) {
77949       {
77950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77951       };
77952     } catch (...) {
77953       {
77954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77955       };
77956     }
77957   }
77958
77959   jresult = (void *)result;
77960   return jresult;
77961 }
77962
77963
77964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77965   void * jresult ;
77966   Dali::BaseHandle arg1 ;
77967   Dali::BaseHandle *argp1 ;
77968   Dali::Toolkit::ScrollViewPagePathEffect result;
77969
77970   argp1 = (Dali::BaseHandle *)jarg1;
77971   if (!argp1) {
77972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77973     return 0;
77974   }
77975   arg1 = *argp1;
77976   {
77977     try {
77978       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77979     } catch (std::out_of_range& e) {
77980       {
77981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77982       };
77983     } catch (std::exception& e) {
77984       {
77985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77986       };
77987     } catch (Dali::DaliException e) {
77988       {
77989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77990       };
77991     } catch (...) {
77992       {
77993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77994       };
77995     }
77996   }
77997
77998   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77999   return jresult;
78000 }
78001
78002
78003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
78004   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78005   Dali::Actor arg2 ;
78006   unsigned int arg3 ;
78007   Dali::Actor *argp2 ;
78008
78009   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78010   argp2 = (Dali::Actor *)jarg2;
78011   if (!argp2) {
78012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78013     return ;
78014   }
78015   arg2 = *argp2;
78016   arg3 = (unsigned int)jarg3;
78017   {
78018     try {
78019       (arg1)->ApplyToPage(arg2,arg3);
78020     } catch (std::out_of_range& e) {
78021       {
78022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78023       };
78024     } catch (std::exception& e) {
78025       {
78026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78027       };
78028     } catch (Dali::DaliException e) {
78029       {
78030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78031       };
78032     } catch (...) {
78033       {
78034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78035       };
78036     }
78037   }
78038
78039 }
78040
78041
78042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78043   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78044
78045   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78046   {
78047     try {
78048       delete arg1;
78049     } catch (std::out_of_range& e) {
78050       {
78051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78052       };
78053     } catch (std::exception& e) {
78054       {
78055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78056       };
78057     } catch (Dali::DaliException e) {
78058       {
78059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78060       };
78061     } catch (...) {
78062       {
78063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78064       };
78065     }
78066   }
78067
78068 }
78069
78070
78071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78072   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78073   Dali::Toolkit::ClampState arg2 ;
78074
78075   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78076   arg2 = (Dali::Toolkit::ClampState)jarg2;
78077   if (arg1) (arg1)->x = arg2;
78078 }
78079
78080
78081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78082   int jresult ;
78083   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78084   Dali::Toolkit::ClampState result;
78085
78086   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78087   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78088   jresult = (int)result;
78089   return jresult;
78090 }
78091
78092
78093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78094   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78095   Dali::Toolkit::ClampState arg2 ;
78096
78097   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78098   arg2 = (Dali::Toolkit::ClampState)jarg2;
78099   if (arg1) (arg1)->y = arg2;
78100 }
78101
78102
78103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78104   int jresult ;
78105   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78106   Dali::Toolkit::ClampState result;
78107
78108   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78109   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78110   jresult = (int)result;
78111   return jresult;
78112 }
78113
78114
78115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78116   void * jresult ;
78117   Dali::Toolkit::ClampState2D *result = 0 ;
78118
78119   {
78120     try {
78121       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78122     } catch (std::out_of_range& e) {
78123       {
78124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78125       };
78126     } catch (std::exception& e) {
78127       {
78128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78129       };
78130     } catch (Dali::DaliException e) {
78131       {
78132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78133       };
78134     } catch (...) {
78135       {
78136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78137       };
78138     }
78139   }
78140
78141   jresult = (void *)result;
78142   return jresult;
78143 }
78144
78145
78146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78147   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78148
78149   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78150   {
78151     try {
78152       delete arg1;
78153     } catch (std::out_of_range& e) {
78154       {
78155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78156       };
78157     } catch (std::exception& e) {
78158       {
78159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78160       };
78161     } catch (Dali::DaliException e) {
78162       {
78163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78164       };
78165     } catch (...) {
78166       {
78167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78168       };
78169     }
78170   }
78171
78172 }
78173
78174
78175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78176   void * jresult ;
78177   float arg1 ;
78178   float arg2 ;
78179   bool arg3 ;
78180   Dali::Toolkit::RulerDomain *result = 0 ;
78181
78182   arg1 = (float)jarg1;
78183   arg2 = (float)jarg2;
78184   arg3 = jarg3 ? true : false;
78185   {
78186     try {
78187       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78188     } catch (std::out_of_range& e) {
78189       {
78190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78191       };
78192     } catch (std::exception& e) {
78193       {
78194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78195       };
78196     } catch (Dali::DaliException e) {
78197       {
78198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78199       };
78200     } catch (...) {
78201       {
78202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78203       };
78204     }
78205   }
78206
78207   jresult = (void *)result;
78208   return jresult;
78209 }
78210
78211
78212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78213   void * jresult ;
78214   float arg1 ;
78215   float arg2 ;
78216   Dali::Toolkit::RulerDomain *result = 0 ;
78217
78218   arg1 = (float)jarg1;
78219   arg2 = (float)jarg2;
78220   {
78221     try {
78222       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78223     } catch (std::out_of_range& e) {
78224       {
78225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78226       };
78227     } catch (std::exception& e) {
78228       {
78229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78230       };
78231     } catch (Dali::DaliException e) {
78232       {
78233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78234       };
78235     } catch (...) {
78236       {
78237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78238       };
78239     }
78240   }
78241
78242   jresult = (void *)result;
78243   return jresult;
78244 }
78245
78246
78247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78248   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78249   float arg2 ;
78250
78251   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78252   arg2 = (float)jarg2;
78253   if (arg1) (arg1)->min = arg2;
78254 }
78255
78256
78257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78258   float jresult ;
78259   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78260   float result;
78261
78262   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78263   result = (float) ((arg1)->min);
78264   jresult = result;
78265   return jresult;
78266 }
78267
78268
78269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78270   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78271   float arg2 ;
78272
78273   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78274   arg2 = (float)jarg2;
78275   if (arg1) (arg1)->max = arg2;
78276 }
78277
78278
78279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78280   float jresult ;
78281   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78282   float result;
78283
78284   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78285   result = (float) ((arg1)->max);
78286   jresult = result;
78287   return jresult;
78288 }
78289
78290
78291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78292   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78293   bool arg2 ;
78294
78295   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78296   arg2 = jarg2 ? true : false;
78297   if (arg1) (arg1)->enabled = arg2;
78298 }
78299
78300
78301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78302   unsigned int jresult ;
78303   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78304   bool result;
78305
78306   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78307   result = (bool) ((arg1)->enabled);
78308   jresult = result;
78309   return jresult;
78310 }
78311
78312
78313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78314   float jresult ;
78315   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78316   float arg2 ;
78317   float arg3 ;
78318   float arg4 ;
78319   float result;
78320
78321   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78322   arg2 = (float)jarg2;
78323   arg3 = (float)jarg3;
78324   arg4 = (float)jarg4;
78325   {
78326     try {
78327       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78328     } catch (std::out_of_range& e) {
78329       {
78330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78331       };
78332     } catch (std::exception& e) {
78333       {
78334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78335       };
78336     } catch (Dali::DaliException e) {
78337       {
78338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78339       };
78340     } catch (...) {
78341       {
78342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78343       };
78344     }
78345   }
78346
78347   jresult = result;
78348   return jresult;
78349 }
78350
78351
78352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78353   float jresult ;
78354   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78355   float arg2 ;
78356   float arg3 ;
78357   float result;
78358
78359   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78360   arg2 = (float)jarg2;
78361   arg3 = (float)jarg3;
78362   {
78363     try {
78364       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78365     } catch (std::out_of_range& e) {
78366       {
78367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78368       };
78369     } catch (std::exception& e) {
78370       {
78371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78372       };
78373     } catch (Dali::DaliException e) {
78374       {
78375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78376       };
78377     } catch (...) {
78378       {
78379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78380       };
78381     }
78382   }
78383
78384   jresult = result;
78385   return jresult;
78386 }
78387
78388
78389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78390   float jresult ;
78391   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78392   float arg2 ;
78393   float result;
78394
78395   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78396   arg2 = (float)jarg2;
78397   {
78398     try {
78399       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78400     } catch (std::out_of_range& e) {
78401       {
78402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78403       };
78404     } catch (std::exception& e) {
78405       {
78406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78407       };
78408     } catch (Dali::DaliException e) {
78409       {
78410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78411       };
78412     } catch (...) {
78413       {
78414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78415       };
78416     }
78417   }
78418
78419   jresult = result;
78420   return jresult;
78421 }
78422
78423
78424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78425   float jresult ;
78426   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78427   float arg2 ;
78428   float arg3 ;
78429   float arg4 ;
78430   Dali::Toolkit::ClampState *arg5 = 0 ;
78431   float result;
78432
78433   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78434   arg2 = (float)jarg2;
78435   arg3 = (float)jarg3;
78436   arg4 = (float)jarg4;
78437   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78438   if (!arg5) {
78439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78440     return 0;
78441   }
78442   {
78443     try {
78444       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78445     } catch (std::out_of_range& e) {
78446       {
78447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78448       };
78449     } catch (std::exception& e) {
78450       {
78451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78452       };
78453     } catch (Dali::DaliException e) {
78454       {
78455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78456       };
78457     } catch (...) {
78458       {
78459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78460       };
78461     }
78462   }
78463
78464   jresult = result;
78465   return jresult;
78466 }
78467
78468
78469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78470   float jresult ;
78471   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78472   float result;
78473
78474   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78475   {
78476     try {
78477       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78478     } catch (std::out_of_range& e) {
78479       {
78480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78481       };
78482     } catch (std::exception& e) {
78483       {
78484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78485       };
78486     } catch (Dali::DaliException e) {
78487       {
78488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78489       };
78490     } catch (...) {
78491       {
78492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78493       };
78494     }
78495   }
78496
78497   jresult = result;
78498   return jresult;
78499 }
78500
78501
78502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78503   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78504
78505   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78506   {
78507     try {
78508       delete arg1;
78509     } catch (std::out_of_range& e) {
78510       {
78511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78512       };
78513     } catch (std::exception& e) {
78514       {
78515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78516       };
78517     } catch (Dali::DaliException e) {
78518       {
78519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78520       };
78521     } catch (...) {
78522       {
78523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78524       };
78525     }
78526   }
78527
78528 }
78529
78530
78531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78532   float jresult ;
78533   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78534   float arg2 ;
78535   float arg3 ;
78536   float result;
78537
78538   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78539   arg2 = (float)jarg2;
78540   arg3 = (float)jarg3;
78541   {
78542     try {
78543       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78544     } catch (std::out_of_range& e) {
78545       {
78546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78547       };
78548     } catch (std::exception& e) {
78549       {
78550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78551       };
78552     } catch (Dali::DaliException e) {
78553       {
78554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78555       };
78556     } catch (...) {
78557       {
78558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78559       };
78560     }
78561   }
78562
78563   jresult = result;
78564   return jresult;
78565 }
78566
78567
78568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78569   float jresult ;
78570   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78571   float arg2 ;
78572   float result;
78573
78574   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78575   arg2 = (float)jarg2;
78576   {
78577     try {
78578       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78579     } catch (std::out_of_range& e) {
78580       {
78581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78582       };
78583     } catch (std::exception& e) {
78584       {
78585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78586       };
78587     } catch (Dali::DaliException e) {
78588       {
78589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78590       };
78591     } catch (...) {
78592       {
78593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78594       };
78595     }
78596   }
78597
78598   jresult = result;
78599   return jresult;
78600 }
78601
78602
78603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78604   float jresult ;
78605   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78606   unsigned int arg2 ;
78607   unsigned int *arg3 = 0 ;
78608   bool arg4 ;
78609   float result;
78610
78611   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78612   arg2 = (unsigned int)jarg2;
78613   arg3 = (unsigned int *)jarg3;
78614   arg4 = jarg4 ? true : false;
78615   {
78616     try {
78617       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78618     } catch (std::out_of_range& e) {
78619       {
78620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78621       };
78622     } catch (std::exception& e) {
78623       {
78624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78625       };
78626     } catch (Dali::DaliException e) {
78627       {
78628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78629       };
78630     } catch (...) {
78631       {
78632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78633       };
78634     }
78635   }
78636
78637   jresult = result;
78638   return jresult;
78639 }
78640
78641
78642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78643   unsigned int jresult ;
78644   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78645   float arg2 ;
78646   bool arg3 ;
78647   unsigned int result;
78648
78649   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78650   arg2 = (float)jarg2;
78651   arg3 = jarg3 ? true : false;
78652   {
78653     try {
78654       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78655     } catch (std::out_of_range& e) {
78656       {
78657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78658       };
78659     } catch (std::exception& e) {
78660       {
78661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78662       };
78663     } catch (Dali::DaliException e) {
78664       {
78665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78666       };
78667     } catch (...) {
78668       {
78669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78670       };
78671     }
78672   }
78673
78674   jresult = result;
78675   return jresult;
78676 }
78677
78678
78679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78680   unsigned int jresult ;
78681   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78682   unsigned int result;
78683
78684   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78685   {
78686     try {
78687       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78688     } catch (std::out_of_range& e) {
78689       {
78690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78691       };
78692     } catch (std::exception& e) {
78693       {
78694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78695       };
78696     } catch (Dali::DaliException e) {
78697       {
78698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78699       };
78700     } catch (...) {
78701       {
78702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78703       };
78704     }
78705   }
78706
78707   jresult = result;
78708   return jresult;
78709 }
78710
78711
78712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78713   int jresult ;
78714   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78715   Dali::Toolkit::Ruler::RulerType result;
78716
78717   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78718   {
78719     try {
78720       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78721     } catch (std::out_of_range& e) {
78722       {
78723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78724       };
78725     } catch (std::exception& e) {
78726       {
78727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78728       };
78729     } catch (Dali::DaliException e) {
78730       {
78731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78732       };
78733     } catch (...) {
78734       {
78735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78736       };
78737     }
78738   }
78739
78740   jresult = (int)result;
78741   return jresult;
78742 }
78743
78744
78745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78746   unsigned int jresult ;
78747   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78748   bool result;
78749
78750   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78751   {
78752     try {
78753       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78754     } catch (std::out_of_range& e) {
78755       {
78756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78757       };
78758     } catch (std::exception& e) {
78759       {
78760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78761       };
78762     } catch (Dali::DaliException e) {
78763       {
78764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78765       };
78766     } catch (...) {
78767       {
78768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78769       };
78770     }
78771   }
78772
78773   jresult = result;
78774   return jresult;
78775 }
78776
78777
78778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78779   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78780
78781   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78782   {
78783     try {
78784       (arg1)->Enable();
78785     } catch (std::out_of_range& e) {
78786       {
78787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78788       };
78789     } catch (std::exception& e) {
78790       {
78791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78792       };
78793     } catch (Dali::DaliException e) {
78794       {
78795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78796       };
78797     } catch (...) {
78798       {
78799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78800       };
78801     }
78802   }
78803
78804 }
78805
78806
78807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78808   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78809
78810   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78811   {
78812     try {
78813       (arg1)->Disable();
78814     } catch (std::out_of_range& e) {
78815       {
78816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78817       };
78818     } catch (std::exception& e) {
78819       {
78820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78821       };
78822     } catch (Dali::DaliException e) {
78823       {
78824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78825       };
78826     } catch (...) {
78827       {
78828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78829       };
78830     }
78831   }
78832
78833 }
78834
78835
78836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78837   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78838   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78839   Dali::Toolkit::RulerDomain *argp2 ;
78840
78841   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78842   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78843   if (!argp2) {
78844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78845     return ;
78846   }
78847   arg2 = *argp2;
78848   {
78849     try {
78850       (arg1)->SetDomain(arg2);
78851     } catch (std::out_of_range& e) {
78852       {
78853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78854       };
78855     } catch (std::exception& e) {
78856       {
78857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78858       };
78859     } catch (Dali::DaliException e) {
78860       {
78861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78862       };
78863     } catch (...) {
78864       {
78865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78866       };
78867     }
78868   }
78869
78870 }
78871
78872
78873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78874   void * jresult ;
78875   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78876   Dali::Toolkit::RulerDomain *result = 0 ;
78877
78878   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78879   {
78880     try {
78881       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78882     } catch (std::out_of_range& e) {
78883       {
78884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78885       };
78886     } catch (std::exception& e) {
78887       {
78888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78889       };
78890     } catch (Dali::DaliException e) {
78891       {
78892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78893       };
78894     } catch (...) {
78895       {
78896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78897       };
78898     }
78899   }
78900
78901   jresult = (void *)result;
78902   return jresult;
78903 }
78904
78905
78906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78907   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78908
78909   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78910   {
78911     try {
78912       (arg1)->DisableDomain();
78913     } catch (std::out_of_range& e) {
78914       {
78915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78916       };
78917     } catch (std::exception& e) {
78918       {
78919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78920       };
78921     } catch (Dali::DaliException e) {
78922       {
78923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78924       };
78925     } catch (...) {
78926       {
78927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78928       };
78929     }
78930   }
78931
78932 }
78933
78934
78935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78936   float jresult ;
78937   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78938   float arg2 ;
78939   float arg3 ;
78940   float arg4 ;
78941   float result;
78942
78943   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78944   arg2 = (float)jarg2;
78945   arg3 = (float)jarg3;
78946   arg4 = (float)jarg4;
78947   {
78948     try {
78949       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78950     } catch (std::out_of_range& e) {
78951       {
78952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78953       };
78954     } catch (std::exception& e) {
78955       {
78956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78957       };
78958     } catch (Dali::DaliException e) {
78959       {
78960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78961       };
78962     } catch (...) {
78963       {
78964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78965       };
78966     }
78967   }
78968
78969   jresult = result;
78970   return jresult;
78971 }
78972
78973
78974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78975   float jresult ;
78976   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78977   float arg2 ;
78978   float arg3 ;
78979   float result;
78980
78981   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78982   arg2 = (float)jarg2;
78983   arg3 = (float)jarg3;
78984   {
78985     try {
78986       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78987     } catch (std::out_of_range& e) {
78988       {
78989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78990       };
78991     } catch (std::exception& e) {
78992       {
78993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78994       };
78995     } catch (Dali::DaliException e) {
78996       {
78997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78998       };
78999     } catch (...) {
79000       {
79001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79002       };
79003     }
79004   }
79005
79006   jresult = result;
79007   return jresult;
79008 }
79009
79010
79011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
79012   float jresult ;
79013   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79014   float arg2 ;
79015   float result;
79016
79017   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79018   arg2 = (float)jarg2;
79019   {
79020     try {
79021       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79022     } catch (std::out_of_range& e) {
79023       {
79024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79025       };
79026     } catch (std::exception& e) {
79027       {
79028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79029       };
79030     } catch (Dali::DaliException e) {
79031       {
79032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79033       };
79034     } catch (...) {
79035       {
79036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79037       };
79038     }
79039   }
79040
79041   jresult = result;
79042   return jresult;
79043 }
79044
79045
79046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79047   float jresult ;
79048   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79049   float arg2 ;
79050   float arg3 ;
79051   float arg4 ;
79052   Dali::Toolkit::ClampState *arg5 = 0 ;
79053   float result;
79054
79055   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79056   arg2 = (float)jarg2;
79057   arg3 = (float)jarg3;
79058   arg4 = (float)jarg4;
79059   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79060   if (!arg5) {
79061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79062     return 0;
79063   }
79064   {
79065     try {
79066       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79067     } catch (std::out_of_range& e) {
79068       {
79069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79070       };
79071     } catch (std::exception& e) {
79072       {
79073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79074       };
79075     } catch (Dali::DaliException e) {
79076       {
79077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79078       };
79079     } catch (...) {
79080       {
79081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79082       };
79083     }
79084   }
79085
79086   jresult = result;
79087   return jresult;
79088 }
79089
79090
79091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79092   float jresult ;
79093   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79094   float arg2 ;
79095   float arg3 ;
79096   float arg4 ;
79097   float arg5 ;
79098   float result;
79099
79100   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79101   arg2 = (float)jarg2;
79102   arg3 = (float)jarg3;
79103   arg4 = (float)jarg4;
79104   arg5 = (float)jarg5;
79105   {
79106     try {
79107       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79108     } catch (std::out_of_range& e) {
79109       {
79110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79111       };
79112     } catch (std::exception& e) {
79113       {
79114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79115       };
79116     } catch (Dali::DaliException e) {
79117       {
79118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79119       };
79120     } catch (...) {
79121       {
79122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79123       };
79124     }
79125   }
79126
79127   jresult = result;
79128   return jresult;
79129 }
79130
79131
79132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79133   float jresult ;
79134   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79135   float arg2 ;
79136   float arg3 ;
79137   float arg4 ;
79138   float result;
79139
79140   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79141   arg2 = (float)jarg2;
79142   arg3 = (float)jarg3;
79143   arg4 = (float)jarg4;
79144   {
79145     try {
79146       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79147     } catch (std::out_of_range& e) {
79148       {
79149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79150       };
79151     } catch (std::exception& e) {
79152       {
79153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79154       };
79155     } catch (Dali::DaliException e) {
79156       {
79157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79158       };
79159     } catch (...) {
79160       {
79161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79162       };
79163     }
79164   }
79165
79166   jresult = result;
79167   return jresult;
79168 }
79169
79170
79171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79172   float jresult ;
79173   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79174   float arg2 ;
79175   float arg3 ;
79176   float result;
79177
79178   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79179   arg2 = (float)jarg2;
79180   arg3 = (float)jarg3;
79181   {
79182     try {
79183       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79184     } catch (std::out_of_range& e) {
79185       {
79186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79187       };
79188     } catch (std::exception& e) {
79189       {
79190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79191       };
79192     } catch (Dali::DaliException e) {
79193       {
79194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79195       };
79196     } catch (...) {
79197       {
79198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79199       };
79200     }
79201   }
79202
79203   jresult = result;
79204   return jresult;
79205 }
79206
79207
79208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79209   float jresult ;
79210   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79211   float arg2 ;
79212   float result;
79213
79214   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79215   arg2 = (float)jarg2;
79216   {
79217     try {
79218       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79219     } catch (std::out_of_range& e) {
79220       {
79221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79222       };
79223     } catch (std::exception& e) {
79224       {
79225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79226       };
79227     } catch (Dali::DaliException e) {
79228       {
79229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79230       };
79231     } catch (...) {
79232       {
79233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79234       };
79235     }
79236   }
79237
79238   jresult = result;
79239   return jresult;
79240 }
79241
79242
79243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79244   float jresult ;
79245   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79246   float arg2 ;
79247   float arg3 ;
79248   float arg4 ;
79249   float arg5 ;
79250   Dali::Toolkit::ClampState *arg6 = 0 ;
79251   float result;
79252
79253   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79254   arg2 = (float)jarg2;
79255   arg3 = (float)jarg3;
79256   arg4 = (float)jarg4;
79257   arg5 = (float)jarg5;
79258   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79259   if (!arg6) {
79260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79261     return 0;
79262   }
79263   {
79264     try {
79265       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79266     } catch (std::out_of_range& e) {
79267       {
79268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79269       };
79270     } catch (std::exception& e) {
79271       {
79272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79273       };
79274     } catch (Dali::DaliException e) {
79275       {
79276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79277       };
79278     } catch (...) {
79279       {
79280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79281       };
79282     }
79283   }
79284
79285   jresult = result;
79286   return jresult;
79287 }
79288
79289
79290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79291   void * jresult ;
79292   Dali::Toolkit::DefaultRuler *result = 0 ;
79293
79294   {
79295     try {
79296       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79297     } catch (std::out_of_range& e) {
79298       {
79299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79300       };
79301     } catch (std::exception& e) {
79302       {
79303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79304       };
79305     } catch (Dali::DaliException e) {
79306       {
79307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79308       };
79309     } catch (...) {
79310       {
79311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79312       };
79313     }
79314   }
79315
79316   jresult = (void *)result;
79317   return jresult;
79318 }
79319
79320
79321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79322   float jresult ;
79323   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79324   float arg2 ;
79325   float arg3 ;
79326   float result;
79327
79328   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79329   arg2 = (float)jarg2;
79330   arg3 = (float)jarg3;
79331   {
79332     try {
79333       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79334     } catch (std::out_of_range& e) {
79335       {
79336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79337       };
79338     } catch (std::exception& e) {
79339       {
79340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79341       };
79342     } catch (Dali::DaliException e) {
79343       {
79344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79345       };
79346     } catch (...) {
79347       {
79348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79349       };
79350     }
79351   }
79352
79353   jresult = result;
79354   return jresult;
79355 }
79356
79357
79358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79359   float jresult ;
79360   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79361   unsigned int arg2 ;
79362   unsigned int *arg3 = 0 ;
79363   bool arg4 ;
79364   float result;
79365
79366   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79367   arg2 = (unsigned int)jarg2;
79368   arg3 = (unsigned int *)jarg3;
79369   arg4 = jarg4 ? true : false;
79370   {
79371     try {
79372       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79373     } catch (std::out_of_range& e) {
79374       {
79375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79376       };
79377     } catch (std::exception& e) {
79378       {
79379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79380       };
79381     } catch (Dali::DaliException e) {
79382       {
79383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79384       };
79385     } catch (...) {
79386       {
79387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79388       };
79389     }
79390   }
79391
79392   jresult = result;
79393   return jresult;
79394 }
79395
79396
79397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79398   unsigned int jresult ;
79399   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79400   float arg2 ;
79401   bool arg3 ;
79402   unsigned int result;
79403
79404   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79405   arg2 = (float)jarg2;
79406   arg3 = jarg3 ? true : false;
79407   {
79408     try {
79409       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79410     } catch (std::out_of_range& e) {
79411       {
79412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79413       };
79414     } catch (std::exception& e) {
79415       {
79416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79417       };
79418     } catch (Dali::DaliException e) {
79419       {
79420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79421       };
79422     } catch (...) {
79423       {
79424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79425       };
79426     }
79427   }
79428
79429   jresult = result;
79430   return jresult;
79431 }
79432
79433
79434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79435   unsigned int jresult ;
79436   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79437   unsigned int result;
79438
79439   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79440   {
79441     try {
79442       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79443     } catch (std::out_of_range& e) {
79444       {
79445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79446       };
79447     } catch (std::exception& e) {
79448       {
79449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79450       };
79451     } catch (Dali::DaliException e) {
79452       {
79453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79454       };
79455     } catch (...) {
79456       {
79457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79458       };
79459     }
79460   }
79461
79462   jresult = result;
79463   return jresult;
79464 }
79465
79466
79467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79468   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79469
79470   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79471   {
79472     try {
79473       delete arg1;
79474     } catch (std::out_of_range& e) {
79475       {
79476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79477       };
79478     } catch (std::exception& e) {
79479       {
79480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79481       };
79482     } catch (Dali::DaliException e) {
79483       {
79484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79485       };
79486     } catch (...) {
79487       {
79488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79489       };
79490     }
79491   }
79492
79493 }
79494
79495
79496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79497   void * jresult ;
79498   float arg1 ;
79499   Dali::Toolkit::FixedRuler *result = 0 ;
79500
79501   arg1 = (float)jarg1;
79502   {
79503     try {
79504       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79505     } catch (std::out_of_range& e) {
79506       {
79507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79508       };
79509     } catch (std::exception& e) {
79510       {
79511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79512       };
79513     } catch (Dali::DaliException e) {
79514       {
79515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79516       };
79517     } catch (...) {
79518       {
79519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79520       };
79521     }
79522   }
79523
79524   jresult = (void *)result;
79525   return jresult;
79526 }
79527
79528
79529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79530   void * jresult ;
79531   Dali::Toolkit::FixedRuler *result = 0 ;
79532
79533   {
79534     try {
79535       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79536     } catch (std::out_of_range& e) {
79537       {
79538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79539       };
79540     } catch (std::exception& e) {
79541       {
79542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79543       };
79544     } catch (Dali::DaliException e) {
79545       {
79546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79547       };
79548     } catch (...) {
79549       {
79550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79551       };
79552     }
79553   }
79554
79555   jresult = (void *)result;
79556   return jresult;
79557 }
79558
79559
79560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79561   float jresult ;
79562   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79563   float arg2 ;
79564   float arg3 ;
79565   float result;
79566
79567   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79568   arg2 = (float)jarg2;
79569   arg3 = (float)jarg3;
79570   {
79571     try {
79572       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79573     } catch (std::out_of_range& e) {
79574       {
79575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79576       };
79577     } catch (std::exception& e) {
79578       {
79579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79580       };
79581     } catch (Dali::DaliException e) {
79582       {
79583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79584       };
79585     } catch (...) {
79586       {
79587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79588       };
79589     }
79590   }
79591
79592   jresult = result;
79593   return jresult;
79594 }
79595
79596
79597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79598   float jresult ;
79599   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79600   unsigned int arg2 ;
79601   unsigned int *arg3 = 0 ;
79602   bool arg4 ;
79603   float result;
79604
79605   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79606   arg2 = (unsigned int)jarg2;
79607   arg3 = (unsigned int *)jarg3;
79608   arg4 = jarg4 ? true : false;
79609   {
79610     try {
79611       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79612     } catch (std::out_of_range& e) {
79613       {
79614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79615       };
79616     } catch (std::exception& e) {
79617       {
79618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79619       };
79620     } catch (Dali::DaliException e) {
79621       {
79622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79623       };
79624     } catch (...) {
79625       {
79626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79627       };
79628     }
79629   }
79630
79631   jresult = result;
79632   return jresult;
79633 }
79634
79635
79636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79637   unsigned int jresult ;
79638   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79639   float arg2 ;
79640   bool arg3 ;
79641   unsigned int result;
79642
79643   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79644   arg2 = (float)jarg2;
79645   arg3 = jarg3 ? true : false;
79646   {
79647     try {
79648       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79649     } catch (std::out_of_range& e) {
79650       {
79651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79652       };
79653     } catch (std::exception& e) {
79654       {
79655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79656       };
79657     } catch (Dali::DaliException e) {
79658       {
79659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79660       };
79661     } catch (...) {
79662       {
79663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79664       };
79665     }
79666   }
79667
79668   jresult = result;
79669   return jresult;
79670 }
79671
79672
79673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79674   unsigned int jresult ;
79675   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79676   unsigned int result;
79677
79678   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79679   {
79680     try {
79681       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79682     } catch (std::out_of_range& e) {
79683       {
79684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79685       };
79686     } catch (std::exception& e) {
79687       {
79688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79689       };
79690     } catch (Dali::DaliException e) {
79691       {
79692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79693       };
79694     } catch (...) {
79695       {
79696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79697       };
79698     }
79699   }
79700
79701   jresult = result;
79702   return jresult;
79703 }
79704
79705
79706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79707   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79708
79709   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79710   {
79711     try {
79712       delete arg1;
79713     } catch (std::out_of_range& e) {
79714       {
79715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79716       };
79717     } catch (std::exception& e) {
79718       {
79719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79720       };
79721     } catch (Dali::DaliException e) {
79722       {
79723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79724       };
79725     } catch (...) {
79726       {
79727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79728       };
79729     }
79730   }
79731
79732 }
79733
79734
79735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79736   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79737   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79738
79739   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79740   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79741   if (arg1) (arg1)->scale = *arg2;
79742 }
79743
79744
79745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79746   void * jresult ;
79747   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79748   Dali::Toolkit::ClampState2D *result = 0 ;
79749
79750   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79751   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79752   jresult = (void *)result;
79753   return jresult;
79754 }
79755
79756
79757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79758   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79759   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79760
79761   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79762   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79763   if (arg1) (arg1)->position = *arg2;
79764 }
79765
79766
79767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79768   void * jresult ;
79769   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79770   Dali::Toolkit::ClampState2D *result = 0 ;
79771
79772   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79773   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79774   jresult = (void *)result;
79775   return jresult;
79776 }
79777
79778
79779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79780   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79781   Dali::Toolkit::ClampState arg2 ;
79782
79783   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79784   arg2 = (Dali::Toolkit::ClampState)jarg2;
79785   if (arg1) (arg1)->rotation = arg2;
79786 }
79787
79788
79789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79790   int jresult ;
79791   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79792   Dali::Toolkit::ClampState result;
79793
79794   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79795   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79796   jresult = (int)result;
79797   return jresult;
79798 }
79799
79800
79801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79802   void * jresult ;
79803   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79804
79805   {
79806     try {
79807       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79808     } catch (std::out_of_range& e) {
79809       {
79810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79811       };
79812     } catch (std::exception& e) {
79813       {
79814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79815       };
79816     } catch (Dali::DaliException e) {
79817       {
79818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79819       };
79820     } catch (...) {
79821       {
79822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79823       };
79824     }
79825   }
79826
79827   jresult = (void *)result;
79828   return jresult;
79829 }
79830
79831
79832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79833   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79834
79835   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79836   {
79837     try {
79838       delete arg1;
79839     } catch (std::out_of_range& e) {
79840       {
79841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79842       };
79843     } catch (std::exception& e) {
79844       {
79845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79846       };
79847     } catch (Dali::DaliException e) {
79848       {
79849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79850       };
79851     } catch (...) {
79852       {
79853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79854       };
79855     }
79856   }
79857
79858 }
79859
79860
79861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79862   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79863   Dali::Toolkit::SnapType arg2 ;
79864
79865   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79866   arg2 = (Dali::Toolkit::SnapType)jarg2;
79867   if (arg1) (arg1)->type = arg2;
79868 }
79869
79870
79871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79872   int jresult ;
79873   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79874   Dali::Toolkit::SnapType result;
79875
79876   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79877   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79878   jresult = (int)result;
79879   return jresult;
79880 }
79881
79882
79883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79884   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79885   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79886
79887   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79888   arg2 = (Dali::Vector2 *)jarg2;
79889   if (arg1) (arg1)->position = *arg2;
79890 }
79891
79892
79893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79894   void * jresult ;
79895   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79896   Dali::Vector2 *result = 0 ;
79897
79898   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79899   result = (Dali::Vector2 *)& ((arg1)->position);
79900   jresult = (void *)result;
79901   return jresult;
79902 }
79903
79904
79905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79906   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79907   float arg2 ;
79908
79909   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79910   arg2 = (float)jarg2;
79911   if (arg1) (arg1)->duration = arg2;
79912 }
79913
79914
79915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79916   float jresult ;
79917   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79918   float result;
79919
79920   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79921   result = (float) ((arg1)->duration);
79922   jresult = result;
79923   return jresult;
79924 }
79925
79926
79927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79928   void * jresult ;
79929   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79930
79931   {
79932     try {
79933       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79934     } catch (std::out_of_range& e) {
79935       {
79936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79937       };
79938     } catch (std::exception& e) {
79939       {
79940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79941       };
79942     } catch (Dali::DaliException e) {
79943       {
79944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79945       };
79946     } catch (...) {
79947       {
79948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79949       };
79950     }
79951   }
79952
79953   jresult = (void *)result;
79954   return jresult;
79955 }
79956
79957
79958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79959   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79960
79961   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79962   {
79963     try {
79964       delete arg1;
79965     } catch (std::out_of_range& e) {
79966       {
79967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79968       };
79969     } catch (std::exception& e) {
79970       {
79971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79972       };
79973     } catch (Dali::DaliException e) {
79974       {
79975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79976       };
79977     } catch (...) {
79978       {
79979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79980       };
79981     }
79982   }
79983
79984 }
79985
79986
79987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79988   int jresult ;
79989   int result;
79990
79991   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79992   jresult = (int)result;
79993   return jresult;
79994 }
79995
79996
79997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79998   int jresult ;
79999   int result;
80000
80001   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
80002   jresult = (int)result;
80003   return jresult;
80004 }
80005
80006
80007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
80008   int jresult ;
80009   int result;
80010
80011   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80012   jresult = (int)result;
80013   return jresult;
80014 }
80015
80016
80017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80018   int jresult ;
80019   int result;
80020
80021   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80022   jresult = (int)result;
80023   return jresult;
80024 }
80025
80026
80027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80028   int jresult ;
80029   int result;
80030
80031   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80032   jresult = (int)result;
80033   return jresult;
80034 }
80035
80036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80037   int jresult ;
80038   int result;
80039
80040   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80041   jresult = (int)result;
80042   return jresult;
80043 }
80044
80045
80046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80047   int jresult ;
80048   int result;
80049
80050   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80051   jresult = (int)result;
80052   return jresult;
80053 }
80054
80055
80056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80057   int jresult ;
80058   int result;
80059
80060   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80061   jresult = (int)result;
80062   return jresult;
80063 }
80064
80065
80066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80067   int jresult ;
80068   int result;
80069
80070   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80071   jresult = (int)result;
80072   return jresult;
80073 }
80074
80075
80076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80077   int jresult ;
80078   int result;
80079
80080   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80081   jresult = (int)result;
80082   return jresult;
80083 }
80084
80085
80086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80087   int jresult ;
80088   int result;
80089
80090   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80091   jresult = (int)result;
80092   return jresult;
80093 }
80094
80095
80096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80097   int jresult ;
80098   int result;
80099
80100   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80101   jresult = (int)result;
80102   return jresult;
80103 }
80104
80105
80106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80107   int jresult ;
80108   int result;
80109
80110   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80111   jresult = (int)result;
80112   return jresult;
80113 }
80114
80115
80116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80117   int jresult ;
80118   int result;
80119
80120   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80121   jresult = (int)result;
80122   return jresult;
80123 }
80124
80125
80126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80127   int jresult ;
80128   int result;
80129
80130   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80131   jresult = (int)result;
80132   return jresult;
80133 }
80134
80135
80136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80137   int jresult ;
80138   int result;
80139
80140   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80141   jresult = (int)result;
80142   return jresult;
80143 }
80144
80145
80146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80147   int jresult ;
80148   int result;
80149
80150   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80151   jresult = (int)result;
80152   return jresult;
80153 }
80154
80155
80156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80157   int jresult ;
80158   int result;
80159
80160   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80161   jresult = (int)result;
80162   return jresult;
80163 }
80164
80165
80166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80167   int jresult ;
80168   int result;
80169
80170   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80171   jresult = (int)result;
80172   return jresult;
80173 }
80174
80175
80176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80177   int jresult ;
80178   int result;
80179
80180   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80181   jresult = (int)result;
80182   return jresult;
80183 }
80184
80185
80186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80187   int jresult ;
80188   int result;
80189
80190   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80191   jresult = (int)result;
80192   return jresult;
80193 }
80194
80195
80196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80197   int jresult ;
80198   int result;
80199
80200   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80201   jresult = (int)result;
80202   return jresult;
80203 }
80204
80205
80206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80207   int jresult ;
80208   int result;
80209
80210   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80211   jresult = (int)result;
80212   return jresult;
80213 }
80214
80215
80216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80217   int jresult ;
80218   int result;
80219
80220   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80221   jresult = (int)result;
80222   return jresult;
80223 }
80224
80225
80226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80227   int jresult ;
80228   int result;
80229
80230   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80231   jresult = (int)result;
80232   return jresult;
80233 }
80234
80235
80236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80237   int jresult ;
80238   int result;
80239
80240   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80241   jresult = (int)result;
80242   return jresult;
80243 }
80244
80245
80246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80247   void * jresult ;
80248   Dali::Toolkit::ScrollView::Property *result = 0 ;
80249
80250   {
80251     try {
80252       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80253     } catch (std::out_of_range& e) {
80254       {
80255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80256       };
80257     } catch (std::exception& e) {
80258       {
80259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80260       };
80261     } catch (Dali::DaliException e) {
80262       {
80263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80264       };
80265     } catch (...) {
80266       {
80267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80268       };
80269     }
80270   }
80271
80272   jresult = (void *)result;
80273   return jresult;
80274 }
80275
80276
80277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80278   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80279
80280   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80281   {
80282     try {
80283       delete arg1;
80284     } catch (std::out_of_range& e) {
80285       {
80286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80287       };
80288     } catch (std::exception& e) {
80289       {
80290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80291       };
80292     } catch (Dali::DaliException e) {
80293       {
80294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80295       };
80296     } catch (...) {
80297       {
80298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80299       };
80300     }
80301   }
80302
80303 }
80304
80305
80306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80307   void * jresult ;
80308   Dali::Toolkit::ScrollView *result = 0 ;
80309
80310   {
80311     try {
80312       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80313     } catch (std::out_of_range& e) {
80314       {
80315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80316       };
80317     } catch (std::exception& e) {
80318       {
80319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80320       };
80321     } catch (Dali::DaliException e) {
80322       {
80323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80324       };
80325     } catch (...) {
80326       {
80327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80328       };
80329     }
80330   }
80331
80332   jresult = (void *)result;
80333   return jresult;
80334 }
80335
80336
80337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80338   void * jresult ;
80339   Dali::Toolkit::ScrollView *arg1 = 0 ;
80340   Dali::Toolkit::ScrollView *result = 0 ;
80341
80342   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80343   if (!arg1) {
80344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80345     return 0;
80346   }
80347   {
80348     try {
80349       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80350     } catch (std::out_of_range& e) {
80351       {
80352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80353       };
80354     } catch (std::exception& e) {
80355       {
80356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80357       };
80358     } catch (Dali::DaliException e) {
80359       {
80360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80361       };
80362     } catch (...) {
80363       {
80364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80365       };
80366     }
80367   }
80368
80369   jresult = (void *)result;
80370   return jresult;
80371 }
80372
80373
80374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80375   void * jresult ;
80376   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80377   Dali::Toolkit::ScrollView *arg2 = 0 ;
80378   Dali::Toolkit::ScrollView *result = 0 ;
80379
80380   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80381   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80382   if (!arg2) {
80383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80384     return 0;
80385   }
80386   {
80387     try {
80388       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80389     } catch (std::out_of_range& e) {
80390       {
80391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80392       };
80393     } catch (std::exception& e) {
80394       {
80395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80396       };
80397     } catch (Dali::DaliException e) {
80398       {
80399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80400       };
80401     } catch (...) {
80402       {
80403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80404       };
80405     }
80406   }
80407
80408   jresult = (void *)result;
80409   return jresult;
80410 }
80411
80412
80413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80414   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80415
80416   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80417   {
80418     try {
80419       delete arg1;
80420     } catch (std::out_of_range& e) {
80421       {
80422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80423       };
80424     } catch (std::exception& e) {
80425       {
80426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80427       };
80428     } catch (Dali::DaliException e) {
80429       {
80430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80431       };
80432     } catch (...) {
80433       {
80434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80435       };
80436     }
80437   }
80438
80439 }
80440
80441
80442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80443   void * jresult ;
80444   Dali::Toolkit::ScrollView result;
80445
80446   {
80447     try {
80448       result = Dali::Toolkit::ScrollView::New();
80449     } catch (std::out_of_range& e) {
80450       {
80451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80452       };
80453     } catch (std::exception& e) {
80454       {
80455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80456       };
80457     } catch (Dali::DaliException e) {
80458       {
80459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80460       };
80461     } catch (...) {
80462       {
80463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80464       };
80465     }
80466   }
80467
80468   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80469   return jresult;
80470 }
80471
80472
80473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80474   void * jresult ;
80475   Dali::BaseHandle arg1 ;
80476   Dali::BaseHandle *argp1 ;
80477   Dali::Toolkit::ScrollView result;
80478
80479   argp1 = (Dali::BaseHandle *)jarg1;
80480   if (!argp1) {
80481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80482     return 0;
80483   }
80484   arg1 = *argp1;
80485   {
80486     try {
80487       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80488     } catch (std::out_of_range& e) {
80489       {
80490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80491       };
80492     } catch (std::exception& e) {
80493       {
80494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80495       };
80496     } catch (Dali::DaliException e) {
80497       {
80498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80499       };
80500     } catch (...) {
80501       {
80502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80503       };
80504     }
80505   }
80506
80507   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80508   return jresult;
80509 }
80510
80511
80512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80513   void * jresult ;
80514   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80515   Dali::AlphaFunction result;
80516
80517   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80518   {
80519     try {
80520       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80521     } catch (std::out_of_range& e) {
80522       {
80523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80524       };
80525     } catch (std::exception& e) {
80526       {
80527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80528       };
80529     } catch (Dali::DaliException e) {
80530       {
80531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80532       };
80533     } catch (...) {
80534       {
80535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80536       };
80537     }
80538   }
80539
80540   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80541   return jresult;
80542 }
80543
80544
80545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80546   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80547   Dali::AlphaFunction arg2 ;
80548   Dali::AlphaFunction *argp2 ;
80549
80550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80551   argp2 = (Dali::AlphaFunction *)jarg2;
80552   if (!argp2) {
80553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80554     return ;
80555   }
80556   arg2 = *argp2;
80557   {
80558     try {
80559       (arg1)->SetScrollSnapAlphaFunction(arg2);
80560     } catch (std::out_of_range& e) {
80561       {
80562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80563       };
80564     } catch (std::exception& e) {
80565       {
80566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80567       };
80568     } catch (Dali::DaliException e) {
80569       {
80570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80571       };
80572     } catch (...) {
80573       {
80574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80575       };
80576     }
80577   }
80578
80579 }
80580
80581
80582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80583   void * jresult ;
80584   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80585   Dali::AlphaFunction result;
80586
80587   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80588   {
80589     try {
80590       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80591     } catch (std::out_of_range& e) {
80592       {
80593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80594       };
80595     } catch (std::exception& e) {
80596       {
80597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80598       };
80599     } catch (Dali::DaliException e) {
80600       {
80601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80602       };
80603     } catch (...) {
80604       {
80605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80606       };
80607     }
80608   }
80609
80610   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80611   return jresult;
80612 }
80613
80614
80615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80616   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80617   Dali::AlphaFunction arg2 ;
80618   Dali::AlphaFunction *argp2 ;
80619
80620   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80621   argp2 = (Dali::AlphaFunction *)jarg2;
80622   if (!argp2) {
80623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80624     return ;
80625   }
80626   arg2 = *argp2;
80627   {
80628     try {
80629       (arg1)->SetScrollFlickAlphaFunction(arg2);
80630     } catch (std::out_of_range& e) {
80631       {
80632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80633       };
80634     } catch (std::exception& e) {
80635       {
80636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80637       };
80638     } catch (Dali::DaliException e) {
80639       {
80640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80641       };
80642     } catch (...) {
80643       {
80644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80645       };
80646     }
80647   }
80648
80649 }
80650
80651
80652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80653   float jresult ;
80654   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80655   float result;
80656
80657   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80658   {
80659     try {
80660       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80661     } catch (std::out_of_range& e) {
80662       {
80663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80664       };
80665     } catch (std::exception& e) {
80666       {
80667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80668       };
80669     } catch (Dali::DaliException e) {
80670       {
80671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80672       };
80673     } catch (...) {
80674       {
80675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80676       };
80677     }
80678   }
80679
80680   jresult = result;
80681   return jresult;
80682 }
80683
80684
80685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80686   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80687   float arg2 ;
80688
80689   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80690   arg2 = (float)jarg2;
80691   {
80692     try {
80693       (arg1)->SetScrollSnapDuration(arg2);
80694     } catch (std::out_of_range& e) {
80695       {
80696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80697       };
80698     } catch (std::exception& e) {
80699       {
80700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80701       };
80702     } catch (Dali::DaliException e) {
80703       {
80704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80705       };
80706     } catch (...) {
80707       {
80708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80709       };
80710     }
80711   }
80712
80713 }
80714
80715
80716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80717   float jresult ;
80718   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80719   float result;
80720
80721   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80722   {
80723     try {
80724       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80725     } catch (std::out_of_range& e) {
80726       {
80727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80728       };
80729     } catch (std::exception& e) {
80730       {
80731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80732       };
80733     } catch (Dali::DaliException e) {
80734       {
80735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80736       };
80737     } catch (...) {
80738       {
80739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80740       };
80741     }
80742   }
80743
80744   jresult = result;
80745   return jresult;
80746 }
80747
80748
80749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80750   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80751   float arg2 ;
80752
80753   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80754   arg2 = (float)jarg2;
80755   {
80756     try {
80757       (arg1)->SetScrollFlickDuration(arg2);
80758     } catch (std::out_of_range& e) {
80759       {
80760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80761       };
80762     } catch (std::exception& e) {
80763       {
80764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80765       };
80766     } catch (Dali::DaliException e) {
80767       {
80768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80769       };
80770     } catch (...) {
80771       {
80772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80773       };
80774     }
80775   }
80776
80777 }
80778
80779
80780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80781   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80782   Dali::Toolkit::RulerPtr arg2 ;
80783   Dali::Toolkit::RulerPtr *argp2 ;
80784
80785   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80786   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80787   if (!argp2) {
80788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80789     return ;
80790   }
80791   arg2 = *argp2;
80792   {
80793     try {
80794       (arg1)->SetRulerX(arg2);
80795     } catch (std::out_of_range& e) {
80796       {
80797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80798       };
80799     } catch (std::exception& e) {
80800       {
80801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80802       };
80803     } catch (Dali::DaliException e) {
80804       {
80805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80806       };
80807     } catch (...) {
80808       {
80809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80810       };
80811     }
80812   }
80813
80814 }
80815
80816
80817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80819   Dali::Toolkit::RulerPtr arg2 ;
80820   Dali::Toolkit::RulerPtr *argp2 ;
80821
80822   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80823   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80824   if (!argp2) {
80825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80826     return ;
80827   }
80828   arg2 = *argp2;
80829   {
80830     try {
80831       (arg1)->SetRulerY(arg2);
80832     } catch (std::out_of_range& e) {
80833       {
80834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80835       };
80836     } catch (std::exception& e) {
80837       {
80838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80839       };
80840     } catch (Dali::DaliException e) {
80841       {
80842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80843       };
80844     } catch (...) {
80845       {
80846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80847       };
80848     }
80849   }
80850
80851 }
80852
80853
80854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80855   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80856   bool arg2 ;
80857
80858   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80859   arg2 = jarg2 ? true : false;
80860   {
80861     try {
80862       (arg1)->SetScrollSensitive(arg2);
80863     } catch (std::out_of_range& e) {
80864       {
80865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80866       };
80867     } catch (std::exception& e) {
80868       {
80869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80870       };
80871     } catch (Dali::DaliException e) {
80872       {
80873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80874       };
80875     } catch (...) {
80876       {
80877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80878       };
80879     }
80880   }
80881
80882 }
80883
80884
80885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80886   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80887   float arg2 ;
80888   float arg3 ;
80889
80890   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80891   arg2 = (float)jarg2;
80892   arg3 = (float)jarg3;
80893   {
80894     try {
80895       (arg1)->SetMaxOvershoot(arg2,arg3);
80896     } catch (std::out_of_range& e) {
80897       {
80898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80899       };
80900     } catch (std::exception& e) {
80901       {
80902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80903       };
80904     } catch (Dali::DaliException e) {
80905       {
80906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80907       };
80908     } catch (...) {
80909       {
80910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80911       };
80912     }
80913   }
80914
80915 }
80916
80917
80918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80919   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80920   Dali::AlphaFunction arg2 ;
80921   Dali::AlphaFunction *argp2 ;
80922
80923   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80924   argp2 = (Dali::AlphaFunction *)jarg2;
80925   if (!argp2) {
80926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80927     return ;
80928   }
80929   arg2 = *argp2;
80930   {
80931     try {
80932       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80933     } catch (std::out_of_range& e) {
80934       {
80935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80936       };
80937     } catch (std::exception& e) {
80938       {
80939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80940       };
80941     } catch (Dali::DaliException e) {
80942       {
80943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80944       };
80945     } catch (...) {
80946       {
80947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80948       };
80949     }
80950   }
80951
80952 }
80953
80954
80955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80956   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80957   float arg2 ;
80958
80959   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80960   arg2 = (float)jarg2;
80961   {
80962     try {
80963       (arg1)->SetSnapOvershootDuration(arg2);
80964     } catch (std::out_of_range& e) {
80965       {
80966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80967       };
80968     } catch (std::exception& e) {
80969       {
80970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80971       };
80972     } catch (Dali::DaliException e) {
80973       {
80974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80975       };
80976     } catch (...) {
80977       {
80978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80979       };
80980     }
80981   }
80982
80983 }
80984
80985
80986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80988   bool arg2 ;
80989
80990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80991   arg2 = jarg2 ? true : false;
80992   {
80993     try {
80994       (arg1)->SetActorAutoSnap(arg2);
80995     } catch (std::out_of_range& e) {
80996       {
80997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80998       };
80999     } catch (std::exception& e) {
81000       {
81001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81002       };
81003     } catch (Dali::DaliException e) {
81004       {
81005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81006       };
81007     } catch (...) {
81008       {
81009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81010       };
81011     }
81012   }
81013
81014 }
81015
81016
81017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81018   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81019   bool arg2 ;
81020
81021   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81022   arg2 = jarg2 ? true : false;
81023   {
81024     try {
81025       (arg1)->SetWrapMode(arg2);
81026     } catch (std::out_of_range& e) {
81027       {
81028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81029       };
81030     } catch (std::exception& e) {
81031       {
81032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81033       };
81034     } catch (Dali::DaliException e) {
81035       {
81036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81037       };
81038     } catch (...) {
81039       {
81040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81041       };
81042     }
81043   }
81044
81045 }
81046
81047
81048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81049   int jresult ;
81050   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81051   int result;
81052
81053   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81054   {
81055     try {
81056       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
81057     } catch (std::out_of_range& e) {
81058       {
81059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81060       };
81061     } catch (std::exception& e) {
81062       {
81063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81064       };
81065     } catch (Dali::DaliException e) {
81066       {
81067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81068       };
81069     } catch (...) {
81070       {
81071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81072       };
81073     }
81074   }
81075
81076   jresult = result;
81077   return jresult;
81078 }
81079
81080
81081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81082   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81083   int arg2 ;
81084
81085   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81086   arg2 = (int)jarg2;
81087   {
81088     try {
81089       (arg1)->SetScrollUpdateDistance(arg2);
81090     } catch (std::out_of_range& e) {
81091       {
81092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81093       };
81094     } catch (std::exception& e) {
81095       {
81096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81097       };
81098     } catch (Dali::DaliException e) {
81099       {
81100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81101       };
81102     } catch (...) {
81103       {
81104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81105       };
81106     }
81107   }
81108
81109 }
81110
81111
81112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81113   unsigned int jresult ;
81114   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81115   bool result;
81116
81117   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81118   {
81119     try {
81120       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81121     } catch (std::out_of_range& e) {
81122       {
81123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81124       };
81125     } catch (std::exception& e) {
81126       {
81127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81128       };
81129     } catch (Dali::DaliException e) {
81130       {
81131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81132       };
81133     } catch (...) {
81134       {
81135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81136       };
81137     }
81138   }
81139
81140   jresult = result;
81141   return jresult;
81142 }
81143
81144
81145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81147   bool arg2 ;
81148
81149   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81150   arg2 = jarg2 ? true : false;
81151   {
81152     try {
81153       (arg1)->SetAxisAutoLock(arg2);
81154     } catch (std::out_of_range& e) {
81155       {
81156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81157       };
81158     } catch (std::exception& e) {
81159       {
81160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81161       };
81162     } catch (Dali::DaliException e) {
81163       {
81164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81165       };
81166     } catch (...) {
81167       {
81168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81169       };
81170     }
81171   }
81172
81173 }
81174
81175
81176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81177   float jresult ;
81178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81179   float result;
81180
81181   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81182   {
81183     try {
81184       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81185     } catch (std::out_of_range& e) {
81186       {
81187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81188       };
81189     } catch (std::exception& e) {
81190       {
81191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81192       };
81193     } catch (Dali::DaliException e) {
81194       {
81195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81196       };
81197     } catch (...) {
81198       {
81199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81200       };
81201     }
81202   }
81203
81204   jresult = result;
81205   return jresult;
81206 }
81207
81208
81209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81210   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81211   float arg2 ;
81212
81213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81214   arg2 = (float)jarg2;
81215   {
81216     try {
81217       (arg1)->SetAxisAutoLockGradient(arg2);
81218     } catch (std::out_of_range& e) {
81219       {
81220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81221       };
81222     } catch (std::exception& e) {
81223       {
81224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81225       };
81226     } catch (Dali::DaliException e) {
81227       {
81228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81229       };
81230     } catch (...) {
81231       {
81232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81233       };
81234     }
81235   }
81236
81237 }
81238
81239
81240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81241   float jresult ;
81242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81243   float result;
81244
81245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81246   {
81247     try {
81248       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81249     } catch (std::out_of_range& e) {
81250       {
81251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81252       };
81253     } catch (std::exception& e) {
81254       {
81255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81256       };
81257     } catch (Dali::DaliException e) {
81258       {
81259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81260       };
81261     } catch (...) {
81262       {
81263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81264       };
81265     }
81266   }
81267
81268   jresult = result;
81269   return jresult;
81270 }
81271
81272
81273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81274   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81275   float arg2 ;
81276
81277   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81278   arg2 = (float)jarg2;
81279   {
81280     try {
81281       (arg1)->SetFrictionCoefficient(arg2);
81282     } catch (std::out_of_range& e) {
81283       {
81284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81285       };
81286     } catch (std::exception& e) {
81287       {
81288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81289       };
81290     } catch (Dali::DaliException e) {
81291       {
81292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81293       };
81294     } catch (...) {
81295       {
81296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81297       };
81298     }
81299   }
81300
81301 }
81302
81303
81304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81305   float jresult ;
81306   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81307   float result;
81308
81309   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81310   {
81311     try {
81312       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81313     } catch (std::out_of_range& e) {
81314       {
81315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81316       };
81317     } catch (std::exception& e) {
81318       {
81319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81320       };
81321     } catch (Dali::DaliException e) {
81322       {
81323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81324       };
81325     } catch (...) {
81326       {
81327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81328       };
81329     }
81330   }
81331
81332   jresult = result;
81333   return jresult;
81334 }
81335
81336
81337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81338   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81339   float arg2 ;
81340
81341   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81342   arg2 = (float)jarg2;
81343   {
81344     try {
81345       (arg1)->SetFlickSpeedCoefficient(arg2);
81346     } catch (std::out_of_range& e) {
81347       {
81348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81349       };
81350     } catch (std::exception& e) {
81351       {
81352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81353       };
81354     } catch (Dali::DaliException e) {
81355       {
81356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81357       };
81358     } catch (...) {
81359       {
81360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81361       };
81362     }
81363   }
81364
81365 }
81366
81367
81368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81369   void * jresult ;
81370   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81371   Dali::Vector2 result;
81372
81373   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81374   {
81375     try {
81376       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81377     } catch (std::out_of_range& e) {
81378       {
81379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (std::exception& e) {
81382       {
81383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81384       };
81385     } catch (Dali::DaliException e) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81388       };
81389     } catch (...) {
81390       {
81391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81392       };
81393     }
81394   }
81395
81396   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81397   return jresult;
81398 }
81399
81400
81401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81403   Dali::Vector2 *arg2 = 0 ;
81404
81405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81406   arg2 = (Dali::Vector2 *)jarg2;
81407   if (!arg2) {
81408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81409     return ;
81410   }
81411   {
81412     try {
81413       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81414     } catch (std::out_of_range& e) {
81415       {
81416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81417       };
81418     } catch (std::exception& e) {
81419       {
81420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81421       };
81422     } catch (Dali::DaliException e) {
81423       {
81424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81425       };
81426     } catch (...) {
81427       {
81428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81429       };
81430     }
81431   }
81432
81433 }
81434
81435
81436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81437   float jresult ;
81438   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81439   float result;
81440
81441   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81442   {
81443     try {
81444       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81445     } catch (std::out_of_range& e) {
81446       {
81447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81448       };
81449     } catch (std::exception& e) {
81450       {
81451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81452       };
81453     } catch (Dali::DaliException e) {
81454       {
81455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81456       };
81457     } catch (...) {
81458       {
81459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81460       };
81461     }
81462   }
81463
81464   jresult = result;
81465   return jresult;
81466 }
81467
81468
81469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81470   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81471   float arg2 ;
81472
81473   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81474   arg2 = (float)jarg2;
81475   {
81476     try {
81477       (arg1)->SetMinimumSpeedForFlick(arg2);
81478     } catch (std::out_of_range& e) {
81479       {
81480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81481       };
81482     } catch (std::exception& e) {
81483       {
81484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81485       };
81486     } catch (Dali::DaliException e) {
81487       {
81488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81489       };
81490     } catch (...) {
81491       {
81492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81493       };
81494     }
81495   }
81496
81497 }
81498
81499
81500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81501   float jresult ;
81502   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81503   float result;
81504
81505   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81506   {
81507     try {
81508       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81509     } catch (std::out_of_range& e) {
81510       {
81511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81512       };
81513     } catch (std::exception& e) {
81514       {
81515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81516       };
81517     } catch (Dali::DaliException e) {
81518       {
81519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81520       };
81521     } catch (...) {
81522       {
81523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81524       };
81525     }
81526   }
81527
81528   jresult = result;
81529   return jresult;
81530 }
81531
81532
81533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81534   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81535   float arg2 ;
81536
81537   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81538   arg2 = (float)jarg2;
81539   {
81540     try {
81541       (arg1)->SetMaxFlickSpeed(arg2);
81542     } catch (std::out_of_range& e) {
81543       {
81544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81545       };
81546     } catch (std::exception& e) {
81547       {
81548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81549       };
81550     } catch (Dali::DaliException e) {
81551       {
81552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81553       };
81554     } catch (...) {
81555       {
81556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81557       };
81558     }
81559   }
81560
81561 }
81562
81563
81564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81565   void * jresult ;
81566   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81567   Dali::Vector2 result;
81568
81569   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81570   {
81571     try {
81572       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81573     } catch (std::out_of_range& e) {
81574       {
81575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81576       };
81577     } catch (std::exception& e) {
81578       {
81579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81580       };
81581     } catch (Dali::DaliException e) {
81582       {
81583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81584       };
81585     } catch (...) {
81586       {
81587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81588       };
81589     }
81590   }
81591
81592   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81593   return jresult;
81594 }
81595
81596
81597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81598   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81599   Dali::Vector2 arg2 ;
81600   Dali::Vector2 *argp2 ;
81601
81602   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81603   argp2 = (Dali::Vector2 *)jarg2;
81604   if (!argp2) {
81605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81606     return ;
81607   }
81608   arg2 = *argp2;
81609   {
81610     try {
81611       (arg1)->SetWheelScrollDistanceStep(arg2);
81612     } catch (std::out_of_range& e) {
81613       {
81614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81615       };
81616     } catch (std::exception& e) {
81617       {
81618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81619       };
81620     } catch (Dali::DaliException e) {
81621       {
81622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81623       };
81624     } catch (...) {
81625       {
81626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81627       };
81628     }
81629   }
81630
81631 }
81632
81633
81634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81635   void * jresult ;
81636   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81637   Dali::Vector2 result;
81638
81639   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81640   {
81641     try {
81642       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81643     } catch (std::out_of_range& e) {
81644       {
81645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81646       };
81647     } catch (std::exception& e) {
81648       {
81649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81650       };
81651     } catch (Dali::DaliException e) {
81652       {
81653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81654       };
81655     } catch (...) {
81656       {
81657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81658       };
81659     }
81660   }
81661
81662   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81663   return jresult;
81664 }
81665
81666
81667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81668   unsigned int jresult ;
81669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81670   unsigned int result;
81671
81672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81673   {
81674     try {
81675       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81676     } catch (std::out_of_range& e) {
81677       {
81678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81679       };
81680     } catch (std::exception& e) {
81681       {
81682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81683       };
81684     } catch (Dali::DaliException e) {
81685       {
81686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81687       };
81688     } catch (...) {
81689       {
81690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81691       };
81692     }
81693   }
81694
81695   jresult = result;
81696   return jresult;
81697 }
81698
81699
81700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81702   Dali::Vector2 *arg2 = 0 ;
81703
81704   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81705   arg2 = (Dali::Vector2 *)jarg2;
81706   if (!arg2) {
81707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81708     return ;
81709   }
81710   {
81711     try {
81712       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81713     } catch (std::out_of_range& e) {
81714       {
81715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81716       };
81717     } catch (std::exception& e) {
81718       {
81719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81720       };
81721     } catch (Dali::DaliException e) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81724       };
81725     } catch (...) {
81726       {
81727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81728       };
81729     }
81730   }
81731
81732 }
81733
81734
81735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81736   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81737   Dali::Vector2 *arg2 = 0 ;
81738   float arg3 ;
81739
81740   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81741   arg2 = (Dali::Vector2 *)jarg2;
81742   if (!arg2) {
81743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81744     return ;
81745   }
81746   arg3 = (float)jarg3;
81747   {
81748     try {
81749       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81750     } catch (std::out_of_range& e) {
81751       {
81752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81753       };
81754     } catch (std::exception& e) {
81755       {
81756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81757       };
81758     } catch (Dali::DaliException e) {
81759       {
81760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81761       };
81762     } catch (...) {
81763       {
81764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81765       };
81766     }
81767   }
81768
81769 }
81770
81771
81772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81774   Dali::Vector2 *arg2 = 0 ;
81775   float arg3 ;
81776   Dali::AlphaFunction arg4 ;
81777   Dali::AlphaFunction *argp4 ;
81778
81779   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81780   arg2 = (Dali::Vector2 *)jarg2;
81781   if (!arg2) {
81782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81783     return ;
81784   }
81785   arg3 = (float)jarg3;
81786   argp4 = (Dali::AlphaFunction *)jarg4;
81787   if (!argp4) {
81788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81789     return ;
81790   }
81791   arg4 = *argp4;
81792   {
81793     try {
81794       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81795     } catch (std::out_of_range& e) {
81796       {
81797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81798       };
81799     } catch (std::exception& e) {
81800       {
81801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81802       };
81803     } catch (Dali::DaliException e) {
81804       {
81805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81806       };
81807     } catch (...) {
81808       {
81809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81810       };
81811     }
81812   }
81813
81814 }
81815
81816
81817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81819   Dali::Vector2 *arg2 = 0 ;
81820   float arg3 ;
81821   Dali::Toolkit::DirectionBias arg4 ;
81822   Dali::Toolkit::DirectionBias arg5 ;
81823
81824   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81825   arg2 = (Dali::Vector2 *)jarg2;
81826   if (!arg2) {
81827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81828     return ;
81829   }
81830   arg3 = (float)jarg3;
81831   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81832   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81833   {
81834     try {
81835       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81836     } catch (std::out_of_range& e) {
81837       {
81838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81839       };
81840     } catch (std::exception& e) {
81841       {
81842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81843       };
81844     } catch (Dali::DaliException e) {
81845       {
81846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81847       };
81848     } catch (...) {
81849       {
81850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81851       };
81852     }
81853   }
81854
81855 }
81856
81857
81858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81859   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81860   Dali::Vector2 *arg2 = 0 ;
81861   float arg3 ;
81862   Dali::AlphaFunction arg4 ;
81863   Dali::Toolkit::DirectionBias arg5 ;
81864   Dali::Toolkit::DirectionBias arg6 ;
81865   Dali::AlphaFunction *argp4 ;
81866
81867   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81868   arg2 = (Dali::Vector2 *)jarg2;
81869   if (!arg2) {
81870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81871     return ;
81872   }
81873   arg3 = (float)jarg3;
81874   argp4 = (Dali::AlphaFunction *)jarg4;
81875   if (!argp4) {
81876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81877     return ;
81878   }
81879   arg4 = *argp4;
81880   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81881   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81882   {
81883     try {
81884       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81885     } catch (std::out_of_range& e) {
81886       {
81887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81888       };
81889     } catch (std::exception& e) {
81890       {
81891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81892       };
81893     } catch (Dali::DaliException e) {
81894       {
81895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81896       };
81897     } catch (...) {
81898       {
81899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81900       };
81901     }
81902   }
81903
81904 }
81905
81906
81907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81909   unsigned int arg2 ;
81910
81911   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81912   arg2 = (unsigned int)jarg2;
81913   {
81914     try {
81915       (arg1)->ScrollTo(arg2);
81916     } catch (std::out_of_range& e) {
81917       {
81918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81919       };
81920     } catch (std::exception& e) {
81921       {
81922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81923       };
81924     } catch (Dali::DaliException e) {
81925       {
81926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81927       };
81928     } catch (...) {
81929       {
81930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81931       };
81932     }
81933   }
81934
81935 }
81936
81937
81938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81939   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81940   unsigned int arg2 ;
81941   float arg3 ;
81942
81943   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81944   arg2 = (unsigned int)jarg2;
81945   arg3 = (float)jarg3;
81946   {
81947     try {
81948       (arg1)->ScrollTo(arg2,arg3);
81949     } catch (std::out_of_range& e) {
81950       {
81951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81952       };
81953     } catch (std::exception& e) {
81954       {
81955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81956       };
81957     } catch (Dali::DaliException e) {
81958       {
81959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81960       };
81961     } catch (...) {
81962       {
81963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81964       };
81965     }
81966   }
81967
81968 }
81969
81970
81971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81972   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81973   unsigned int arg2 ;
81974   float arg3 ;
81975   Dali::Toolkit::DirectionBias arg4 ;
81976
81977   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81978   arg2 = (unsigned int)jarg2;
81979   arg3 = (float)jarg3;
81980   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81981   {
81982     try {
81983       (arg1)->ScrollTo(arg2,arg3,arg4);
81984     } catch (std::out_of_range& e) {
81985       {
81986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81987       };
81988     } catch (std::exception& e) {
81989       {
81990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81991       };
81992     } catch (Dali::DaliException e) {
81993       {
81994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81995       };
81996     } catch (...) {
81997       {
81998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81999       };
82000     }
82001   }
82002
82003 }
82004
82005
82006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
82007   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82008   Dali::Actor *arg2 = 0 ;
82009
82010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82011   arg2 = (Dali::Actor *)jarg2;
82012   if (!arg2) {
82013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82014     return ;
82015   }
82016   {
82017     try {
82018       (arg1)->ScrollTo(*arg2);
82019     } catch (std::out_of_range& e) {
82020       {
82021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82022       };
82023     } catch (std::exception& e) {
82024       {
82025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82026       };
82027     } catch (Dali::DaliException e) {
82028       {
82029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82030       };
82031     } catch (...) {
82032       {
82033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82034       };
82035     }
82036   }
82037
82038 }
82039
82040
82041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82043   Dali::Actor *arg2 = 0 ;
82044   float arg3 ;
82045
82046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82047   arg2 = (Dali::Actor *)jarg2;
82048   if (!arg2) {
82049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82050     return ;
82051   }
82052   arg3 = (float)jarg3;
82053   {
82054     try {
82055       (arg1)->ScrollTo(*arg2,arg3);
82056     } catch (std::out_of_range& e) {
82057       {
82058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82059       };
82060     } catch (std::exception& e) {
82061       {
82062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82063       };
82064     } catch (Dali::DaliException e) {
82065       {
82066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82067       };
82068     } catch (...) {
82069       {
82070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82071       };
82072     }
82073   }
82074
82075 }
82076
82077
82078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82079   unsigned int jresult ;
82080   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82081   bool result;
82082
82083   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82084   {
82085     try {
82086       result = (bool)(arg1)->ScrollToSnapPoint();
82087     } catch (std::out_of_range& e) {
82088       {
82089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82090       };
82091     } catch (std::exception& e) {
82092       {
82093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82094       };
82095     } catch (Dali::DaliException e) {
82096       {
82097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82098       };
82099     } catch (...) {
82100       {
82101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82102       };
82103     }
82104   }
82105
82106   jresult = result;
82107   return jresult;
82108 }
82109
82110
82111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82112   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82113   Dali::Constraint arg2 ;
82114   Dali::Constraint *argp2 ;
82115
82116   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82117   argp2 = (Dali::Constraint *)jarg2;
82118   if (!argp2) {
82119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82120     return ;
82121   }
82122   arg2 = *argp2;
82123   {
82124     try {
82125       (arg1)->ApplyConstraintToChildren(arg2);
82126     } catch (std::out_of_range& e) {
82127       {
82128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82129       };
82130     } catch (std::exception& e) {
82131       {
82132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82133       };
82134     } catch (Dali::DaliException e) {
82135       {
82136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82137       };
82138     } catch (...) {
82139       {
82140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82141       };
82142     }
82143   }
82144
82145 }
82146
82147
82148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82149   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82150
82151   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82152   {
82153     try {
82154       (arg1)->RemoveConstraintsFromChildren();
82155     } catch (std::out_of_range& e) {
82156       {
82157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82158       };
82159     } catch (std::exception& e) {
82160       {
82161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82162       };
82163     } catch (Dali::DaliException e) {
82164       {
82165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82166       };
82167     } catch (...) {
82168       {
82169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82170       };
82171     }
82172   }
82173
82174 }
82175
82176
82177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82179   Dali::Toolkit::ScrollViewEffect arg2 ;
82180   Dali::Toolkit::ScrollViewEffect *argp2 ;
82181
82182   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82183   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82184   if (!argp2) {
82185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82186     return ;
82187   }
82188   arg2 = *argp2;
82189   {
82190     try {
82191       (arg1)->ApplyEffect(arg2);
82192     } catch (std::out_of_range& e) {
82193       {
82194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82195       };
82196     } catch (std::exception& e) {
82197       {
82198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82199       };
82200     } catch (Dali::DaliException e) {
82201       {
82202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82203       };
82204     } catch (...) {
82205       {
82206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82207       };
82208     }
82209   }
82210
82211 }
82212
82213
82214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82215   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82216   Dali::Toolkit::ScrollViewEffect arg2 ;
82217   Dali::Toolkit::ScrollViewEffect *argp2 ;
82218
82219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82220   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82221   if (!argp2) {
82222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82223     return ;
82224   }
82225   arg2 = *argp2;
82226   {
82227     try {
82228       (arg1)->RemoveEffect(arg2);
82229     } catch (std::out_of_range& e) {
82230       {
82231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82232       };
82233     } catch (std::exception& e) {
82234       {
82235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82236       };
82237     } catch (Dali::DaliException e) {
82238       {
82239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82240       };
82241     } catch (...) {
82242       {
82243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82244       };
82245     }
82246   }
82247
82248 }
82249
82250
82251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82252   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82253
82254   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82255   {
82256     try {
82257       (arg1)->RemoveAllEffects();
82258     } catch (std::out_of_range& e) {
82259       {
82260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82261       };
82262     } catch (std::exception& e) {
82263       {
82264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82265       };
82266     } catch (Dali::DaliException e) {
82267       {
82268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82269       };
82270     } catch (...) {
82271       {
82272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82273       };
82274     }
82275   }
82276
82277 }
82278
82279
82280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82281   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82282   Dali::Actor arg2 ;
82283   Dali::Actor *argp2 ;
82284
82285   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82286   argp2 = (Dali::Actor *)jarg2;
82287   if (!argp2) {
82288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82289     return ;
82290   }
82291   arg2 = *argp2;
82292   {
82293     try {
82294       (arg1)->BindActor(arg2);
82295     } catch (std::out_of_range& e) {
82296       {
82297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82298       };
82299     } catch (std::exception& e) {
82300       {
82301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82302       };
82303     } catch (Dali::DaliException e) {
82304       {
82305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82306       };
82307     } catch (...) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82310       };
82311     }
82312   }
82313
82314 }
82315
82316
82317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82319   Dali::Actor arg2 ;
82320   Dali::Actor *argp2 ;
82321
82322   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82323   argp2 = (Dali::Actor *)jarg2;
82324   if (!argp2) {
82325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82326     return ;
82327   }
82328   arg2 = *argp2;
82329   {
82330     try {
82331       (arg1)->UnbindActor(arg2);
82332     } catch (std::out_of_range& e) {
82333       {
82334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82335       };
82336     } catch (std::exception& e) {
82337       {
82338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82339       };
82340     } catch (Dali::DaliException e) {
82341       {
82342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82343       };
82344     } catch (...) {
82345       {
82346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82347       };
82348     }
82349   }
82350
82351 }
82352
82353
82354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82355   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82356   Dali::Radian arg2 ;
82357   Dali::Radian arg3 ;
82358   Dali::Radian *argp2 ;
82359   Dali::Radian *argp3 ;
82360
82361   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82362   argp2 = (Dali::Radian *)jarg2;
82363   if (!argp2) {
82364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82365     return ;
82366   }
82367   arg2 = *argp2;
82368   argp3 = (Dali::Radian *)jarg3;
82369   if (!argp3) {
82370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82371     return ;
82372   }
82373   arg3 = *argp3;
82374   {
82375     try {
82376       (arg1)->SetScrollingDirection(arg2,arg3);
82377     } catch (std::out_of_range& e) {
82378       {
82379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82380       };
82381     } catch (std::exception& e) {
82382       {
82383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82384       };
82385     } catch (Dali::DaliException e) {
82386       {
82387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82388       };
82389     } catch (...) {
82390       {
82391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82392       };
82393     }
82394   }
82395
82396 }
82397
82398
82399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82400   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82401   Dali::Radian arg2 ;
82402   Dali::Radian *argp2 ;
82403
82404   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82405   argp2 = (Dali::Radian *)jarg2;
82406   if (!argp2) {
82407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82408     return ;
82409   }
82410   arg2 = *argp2;
82411   {
82412     try {
82413       (arg1)->SetScrollingDirection(arg2);
82414     } catch (std::out_of_range& e) {
82415       {
82416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82417       };
82418     } catch (std::exception& e) {
82419       {
82420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82421       };
82422     } catch (Dali::DaliException e) {
82423       {
82424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82425       };
82426     } catch (...) {
82427       {
82428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82429       };
82430     }
82431   }
82432
82433 }
82434
82435
82436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82437   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82438   Dali::Radian arg2 ;
82439   Dali::Radian *argp2 ;
82440
82441   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82442   argp2 = (Dali::Radian *)jarg2;
82443   if (!argp2) {
82444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82445     return ;
82446   }
82447   arg2 = *argp2;
82448   {
82449     try {
82450       (arg1)->RemoveScrollingDirection(arg2);
82451     } catch (std::out_of_range& e) {
82452       {
82453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82454       };
82455     } catch (std::exception& e) {
82456       {
82457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82458       };
82459     } catch (Dali::DaliException e) {
82460       {
82461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82462       };
82463     } catch (...) {
82464       {
82465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82466       };
82467     }
82468   }
82469
82470 }
82471
82472
82473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82474   void * jresult ;
82475   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82476   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82477
82478   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82479   {
82480     try {
82481       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82482     } catch (std::out_of_range& e) {
82483       {
82484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82485       };
82486     } catch (std::exception& e) {
82487       {
82488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82489       };
82490     } catch (Dali::DaliException e) {
82491       {
82492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82493       };
82494     } catch (...) {
82495       {
82496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82497       };
82498     }
82499   }
82500
82501   jresult = (void *)result;
82502   return jresult;
82503 }
82504
82505
82506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82507   int jresult ;
82508   int result;
82509
82510   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82511   jresult = (int)result;
82512   return jresult;
82513 }
82514
82515
82516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82517   int jresult ;
82518   int result;
82519
82520   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82521   jresult = (int)result;
82522   return jresult;
82523 }
82524
82525
82526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82527   int jresult ;
82528   int result;
82529
82530   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82531   jresult = (int)result;
82532   return jresult;
82533 }
82534
82535
82536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82537   int jresult ;
82538   int result;
82539
82540   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82541   jresult = (int)result;
82542   return jresult;
82543 }
82544
82545
82546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82547   int jresult ;
82548   int result;
82549
82550   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82551   jresult = (int)result;
82552   return jresult;
82553 }
82554
82555
82556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82557   void * jresult ;
82558   Dali::Toolkit::TableView::Property *result = 0 ;
82559
82560   {
82561     try {
82562       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82563     } catch (std::out_of_range& e) {
82564       {
82565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82566       };
82567     } catch (std::exception& e) {
82568       {
82569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82570       };
82571     } catch (Dali::DaliException e) {
82572       {
82573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82574       };
82575     } catch (...) {
82576       {
82577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82578       };
82579     }
82580   }
82581
82582   jresult = (void *)result;
82583   return jresult;
82584 }
82585
82586
82587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82588   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82589
82590   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82591   {
82592     try {
82593       delete arg1;
82594     } catch (std::out_of_range& e) {
82595       {
82596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82597       };
82598     } catch (std::exception& e) {
82599       {
82600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82601       };
82602     } catch (Dali::DaliException e) {
82603       {
82604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82605       };
82606     } catch (...) {
82607       {
82608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82609       };
82610     }
82611   }
82612
82613 }
82614
82615
82616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82617   int jresult ;
82618   int result;
82619
82620   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82621   jresult = (int)result;
82622   return jresult;
82623 }
82624
82625
82626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82627   int jresult ;
82628   int result;
82629
82630   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82631   jresult = (int)result;
82632   return jresult;
82633 }
82634
82635
82636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82637   int jresult ;
82638   int result;
82639
82640   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82641   jresult = (int)result;
82642   return jresult;
82643 }
82644
82645
82646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82647   int jresult ;
82648   int result;
82649
82650   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82651   jresult = (int)result;
82652   return jresult;
82653 }
82654
82655
82656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82657   int jresult ;
82658   int result;
82659
82660   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82661   jresult = (int)result;
82662   return jresult;
82663 }
82664
82665
82666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82667   void * jresult ;
82668   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82669
82670   {
82671     try {
82672       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82673     } catch (std::out_of_range& e) {
82674       {
82675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82676       };
82677     } catch (std::exception& e) {
82678       {
82679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82680       };
82681     } catch (Dali::DaliException e) {
82682       {
82683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82684       };
82685     } catch (...) {
82686       {
82687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82688       };
82689     }
82690   }
82691
82692   jresult = (void *)result;
82693   return jresult;
82694 }
82695
82696
82697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82698   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82699
82700   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82701   {
82702     try {
82703       delete arg1;
82704     } catch (std::out_of_range& e) {
82705       {
82706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82707       };
82708     } catch (std::exception& e) {
82709       {
82710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82711       };
82712     } catch (Dali::DaliException e) {
82713       {
82714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82715       };
82716     } catch (...) {
82717       {
82718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82719       };
82720     }
82721   }
82722
82723 }
82724
82725
82726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82727   void * jresult ;
82728   unsigned int arg1 ;
82729   unsigned int arg2 ;
82730   unsigned int arg3 ;
82731   unsigned int arg4 ;
82732   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82733
82734   arg1 = (unsigned int)jarg1;
82735   arg2 = (unsigned int)jarg2;
82736   arg3 = (unsigned int)jarg3;
82737   arg4 = (unsigned int)jarg4;
82738   {
82739     try {
82740       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82741     } catch (std::out_of_range& e) {
82742       {
82743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82744       };
82745     } catch (std::exception& e) {
82746       {
82747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82748       };
82749     } catch (Dali::DaliException e) {
82750       {
82751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82752       };
82753     } catch (...) {
82754       {
82755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82756       };
82757     }
82758   }
82759
82760   jresult = (void *)result;
82761   return jresult;
82762 }
82763
82764
82765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82766   void * jresult ;
82767   unsigned int arg1 ;
82768   unsigned int arg2 ;
82769   unsigned int arg3 ;
82770   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82771
82772   arg1 = (unsigned int)jarg1;
82773   arg2 = (unsigned int)jarg2;
82774   arg3 = (unsigned int)jarg3;
82775   {
82776     try {
82777       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
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 (Dali::DaliException e) {
82787       {
82788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82789       };
82790     } catch (...) {
82791       {
82792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82793       };
82794     }
82795   }
82796
82797   jresult = (void *)result;
82798   return jresult;
82799 }
82800
82801
82802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82803   void * jresult ;
82804   unsigned int arg1 ;
82805   unsigned int arg2 ;
82806   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82807
82808   arg1 = (unsigned int)jarg1;
82809   arg2 = (unsigned int)jarg2;
82810   {
82811     try {
82812       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82813     } catch (std::out_of_range& e) {
82814       {
82815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82816       };
82817     } catch (std::exception& e) {
82818       {
82819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82820       };
82821     } catch (Dali::DaliException e) {
82822       {
82823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82824       };
82825     } catch (...) {
82826       {
82827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82828       };
82829     }
82830   }
82831
82832   jresult = (void *)result;
82833   return jresult;
82834 }
82835
82836
82837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82838   void * jresult ;
82839   unsigned int arg1 ;
82840   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82841
82842   arg1 = (unsigned int)jarg1;
82843   {
82844     try {
82845       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82846     } catch (std::out_of_range& e) {
82847       {
82848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82849       };
82850     } catch (std::exception& e) {
82851       {
82852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82853       };
82854     } catch (Dali::DaliException e) {
82855       {
82856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82857       };
82858     } catch (...) {
82859       {
82860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82861       };
82862     }
82863   }
82864
82865   jresult = (void *)result;
82866   return jresult;
82867 }
82868
82869
82870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82871   void * jresult ;
82872   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82873
82874   {
82875     try {
82876       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82877     } catch (std::out_of_range& e) {
82878       {
82879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82880       };
82881     } catch (std::exception& e) {
82882       {
82883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82884       };
82885     } catch (Dali::DaliException e) {
82886       {
82887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82888       };
82889     } catch (...) {
82890       {
82891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82892       };
82893     }
82894   }
82895
82896   jresult = (void *)result;
82897   return jresult;
82898 }
82899
82900
82901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82902   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82903   unsigned int arg2 ;
82904
82905   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82906   arg2 = (unsigned int)jarg2;
82907   if (arg1) (arg1)->rowIndex = arg2;
82908 }
82909
82910
82911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82912   unsigned int jresult ;
82913   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82914   unsigned int result;
82915
82916   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82917   result = (unsigned int) ((arg1)->rowIndex);
82918   jresult = result;
82919   return jresult;
82920 }
82921
82922
82923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82924   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82925   unsigned int arg2 ;
82926
82927   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82928   arg2 = (unsigned int)jarg2;
82929   if (arg1) (arg1)->columnIndex = arg2;
82930 }
82931
82932
82933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82934   unsigned int jresult ;
82935   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82936   unsigned int result;
82937
82938   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82939   result = (unsigned int) ((arg1)->columnIndex);
82940   jresult = result;
82941   return jresult;
82942 }
82943
82944
82945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82946   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82947   unsigned int arg2 ;
82948
82949   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82950   arg2 = (unsigned int)jarg2;
82951   if (arg1) (arg1)->rowSpan = arg2;
82952 }
82953
82954
82955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82956   unsigned int jresult ;
82957   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82958   unsigned int result;
82959
82960   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82961   result = (unsigned int) ((arg1)->rowSpan);
82962   jresult = result;
82963   return jresult;
82964 }
82965
82966
82967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82968   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82969   unsigned int arg2 ;
82970
82971   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82972   arg2 = (unsigned int)jarg2;
82973   if (arg1) (arg1)->columnSpan = arg2;
82974 }
82975
82976
82977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82978   unsigned int jresult ;
82979   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82980   unsigned int result;
82981
82982   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82983   result = (unsigned int) ((arg1)->columnSpan);
82984   jresult = result;
82985   return jresult;
82986 }
82987
82988
82989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82990   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82991
82992   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82993   {
82994     try {
82995       delete arg1;
82996     } catch (std::out_of_range& e) {
82997       {
82998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82999       };
83000     } catch (std::exception& e) {
83001       {
83002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83003       };
83004     } catch (Dali::DaliException e) {
83005       {
83006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83007       };
83008     } catch (...) {
83009       {
83010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83011       };
83012     }
83013   }
83014
83015 }
83016
83017
83018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83019   void * jresult ;
83020   Dali::Toolkit::TableView *result = 0 ;
83021
83022   {
83023     try {
83024       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83025     } catch (std::out_of_range& e) {
83026       {
83027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83028       };
83029     } catch (std::exception& e) {
83030       {
83031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83032       };
83033     } catch (Dali::DaliException e) {
83034       {
83035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83036       };
83037     } catch (...) {
83038       {
83039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83040       };
83041     }
83042   }
83043
83044   jresult = (void *)result;
83045   return jresult;
83046 }
83047
83048
83049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83050   void * jresult ;
83051   Dali::Toolkit::TableView *arg1 = 0 ;
83052   Dali::Toolkit::TableView *result = 0 ;
83053
83054   arg1 = (Dali::Toolkit::TableView *)jarg1;
83055   if (!arg1) {
83056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83057     return 0;
83058   }
83059   {
83060     try {
83061       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
83062     } catch (std::out_of_range& e) {
83063       {
83064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83065       };
83066     } catch (std::exception& e) {
83067       {
83068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83069       };
83070     } catch (Dali::DaliException e) {
83071       {
83072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83073       };
83074     } catch (...) {
83075       {
83076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83077       };
83078     }
83079   }
83080
83081   jresult = (void *)result;
83082   return jresult;
83083 }
83084
83085
83086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83087   void * jresult ;
83088   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83089   Dali::Toolkit::TableView *arg2 = 0 ;
83090   Dali::Toolkit::TableView *result = 0 ;
83091
83092   arg1 = (Dali::Toolkit::TableView *)jarg1;
83093   arg2 = (Dali::Toolkit::TableView *)jarg2;
83094   if (!arg2) {
83095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83096     return 0;
83097   }
83098   {
83099     try {
83100       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83101     } catch (std::out_of_range& e) {
83102       {
83103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83104       };
83105     } catch (std::exception& e) {
83106       {
83107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83108       };
83109     } catch (Dali::DaliException e) {
83110       {
83111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83112       };
83113     } catch (...) {
83114       {
83115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83116       };
83117     }
83118   }
83119
83120   jresult = (void *)result;
83121   return jresult;
83122 }
83123
83124
83125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83126   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83127
83128   arg1 = (Dali::Toolkit::TableView *)jarg1;
83129   {
83130     try {
83131       delete arg1;
83132     } catch (std::out_of_range& e) {
83133       {
83134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83135       };
83136     } catch (std::exception& e) {
83137       {
83138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83139       };
83140     } catch (Dali::DaliException e) {
83141       {
83142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83143       };
83144     } catch (...) {
83145       {
83146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83147       };
83148     }
83149   }
83150
83151 }
83152
83153
83154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83155   void * jresult ;
83156   unsigned int arg1 ;
83157   unsigned int arg2 ;
83158   Dali::Toolkit::TableView result;
83159
83160   arg1 = (unsigned int)jarg1;
83161   arg2 = (unsigned int)jarg2;
83162   {
83163     try {
83164       result = Dali::Toolkit::TableView::New(arg1,arg2);
83165     } catch (std::out_of_range& e) {
83166       {
83167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83168       };
83169     } catch (std::exception& e) {
83170       {
83171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83172       };
83173     } catch (Dali::DaliException e) {
83174       {
83175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83176       };
83177     } catch (...) {
83178       {
83179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83180       };
83181     }
83182   }
83183
83184   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83185   return jresult;
83186 }
83187
83188
83189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83190   void * jresult ;
83191   Dali::BaseHandle arg1 ;
83192   Dali::BaseHandle *argp1 ;
83193   Dali::Toolkit::TableView result;
83194
83195   argp1 = (Dali::BaseHandle *)jarg1;
83196   if (!argp1) {
83197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83198     return 0;
83199   }
83200   arg1 = *argp1;
83201   {
83202     try {
83203       result = Dali::Toolkit::TableView::DownCast(arg1);
83204     } catch (std::out_of_range& e) {
83205       {
83206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83207       };
83208     } catch (std::exception& e) {
83209       {
83210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83211       };
83212     } catch (Dali::DaliException e) {
83213       {
83214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83215       };
83216     } catch (...) {
83217       {
83218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83219       };
83220     }
83221   }
83222
83223   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83224   return jresult;
83225 }
83226
83227
83228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83229   unsigned int jresult ;
83230   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83231   Dali::Actor arg2 ;
83232   Dali::Toolkit::TableView::CellPosition arg3 ;
83233   Dali::Actor *argp2 ;
83234   Dali::Toolkit::TableView::CellPosition *argp3 ;
83235   bool result;
83236
83237   arg1 = (Dali::Toolkit::TableView *)jarg1;
83238   argp2 = (Dali::Actor *)jarg2;
83239   if (!argp2) {
83240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83241     return 0;
83242   }
83243   arg2 = *argp2;
83244   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83245   if (!argp3) {
83246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83247     return 0;
83248   }
83249   arg3 = *argp3;
83250   {
83251     try {
83252       result = (bool)(arg1)->AddChild(arg2,arg3);
83253     } catch (std::out_of_range& e) {
83254       {
83255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83256       };
83257     } catch (std::exception& e) {
83258       {
83259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83260       };
83261     } catch (Dali::DaliException e) {
83262       {
83263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83264       };
83265     } catch (...) {
83266       {
83267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83268       };
83269     }
83270   }
83271
83272   jresult = result;
83273   return jresult;
83274 }
83275
83276
83277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83278   void * jresult ;
83279   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83280   Dali::Toolkit::TableView::CellPosition arg2 ;
83281   Dali::Toolkit::TableView::CellPosition *argp2 ;
83282   Dali::Actor result;
83283
83284   arg1 = (Dali::Toolkit::TableView *)jarg1;
83285   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83286   if (!argp2) {
83287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83288     return 0;
83289   }
83290   arg2 = *argp2;
83291   {
83292     try {
83293       result = (arg1)->GetChildAt(arg2);
83294     } catch (std::out_of_range& e) {
83295       {
83296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83297       };
83298     } catch (std::exception& e) {
83299       {
83300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83301       };
83302     } catch (Dali::DaliException e) {
83303       {
83304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83305       };
83306     } catch (...) {
83307       {
83308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83309       };
83310     }
83311   }
83312
83313   jresult = new Dali::Actor((const Dali::Actor &)result);
83314   return jresult;
83315 }
83316
83317
83318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83319   void * jresult ;
83320   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83321   Dali::Toolkit::TableView::CellPosition arg2 ;
83322   Dali::Toolkit::TableView::CellPosition *argp2 ;
83323   Dali::Actor result;
83324
83325   arg1 = (Dali::Toolkit::TableView *)jarg1;
83326   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83327   if (!argp2) {
83328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83329     return 0;
83330   }
83331   arg2 = *argp2;
83332   {
83333     try {
83334       result = (arg1)->RemoveChildAt(arg2);
83335     } catch (std::out_of_range& e) {
83336       {
83337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83338       };
83339     } catch (std::exception& e) {
83340       {
83341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83342       };
83343     } catch (Dali::DaliException e) {
83344       {
83345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83346       };
83347     } catch (...) {
83348       {
83349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83350       };
83351     }
83352   }
83353
83354   jresult = new Dali::Actor((const Dali::Actor &)result);
83355   return jresult;
83356 }
83357
83358
83359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83360   unsigned int jresult ;
83361   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83362   Dali::Actor arg2 ;
83363   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83364   Dali::Actor *argp2 ;
83365   bool result;
83366
83367   arg1 = (Dali::Toolkit::TableView *)jarg1;
83368   argp2 = (Dali::Actor *)jarg2;
83369   if (!argp2) {
83370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83371     return 0;
83372   }
83373   arg2 = *argp2;
83374   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83375   if (!arg3) {
83376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83377     return 0;
83378   }
83379   {
83380     try {
83381       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83382     } catch (std::out_of_range& e) {
83383       {
83384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83385       };
83386     } catch (std::exception& e) {
83387       {
83388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83389       };
83390     } catch (Dali::DaliException e) {
83391       {
83392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83393       };
83394     } catch (...) {
83395       {
83396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83397       };
83398     }
83399   }
83400
83401   jresult = result;
83402   return jresult;
83403 }
83404
83405
83406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83407   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83408   unsigned int arg2 ;
83409
83410   arg1 = (Dali::Toolkit::TableView *)jarg1;
83411   arg2 = (unsigned int)jarg2;
83412   {
83413     try {
83414       (arg1)->InsertRow(arg2);
83415     } catch (std::out_of_range& e) {
83416       {
83417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83418       };
83419     } catch (std::exception& e) {
83420       {
83421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83422       };
83423     } catch (Dali::DaliException e) {
83424       {
83425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83426       };
83427     } catch (...) {
83428       {
83429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83430       };
83431     }
83432   }
83433
83434 }
83435
83436
83437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83438   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83439   unsigned int arg2 ;
83440
83441   arg1 = (Dali::Toolkit::TableView *)jarg1;
83442   arg2 = (unsigned int)jarg2;
83443   {
83444     try {
83445       (arg1)->DeleteRow(arg2);
83446     } catch (std::out_of_range& e) {
83447       {
83448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83449       };
83450     } catch (std::exception& e) {
83451       {
83452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83453       };
83454     } catch (Dali::DaliException e) {
83455       {
83456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83457       };
83458     } catch (...) {
83459       {
83460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83461       };
83462     }
83463   }
83464
83465 }
83466
83467
83468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83469   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83470   unsigned int arg2 ;
83471   std::vector< Dali::Actor > *arg3 = 0 ;
83472
83473   arg1 = (Dali::Toolkit::TableView *)jarg1;
83474   arg2 = (unsigned int)jarg2;
83475   arg3 = (std::vector< Dali::Actor > *)jarg3;
83476   if (!arg3) {
83477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83478     return ;
83479   }
83480   {
83481     try {
83482       (arg1)->DeleteRow(arg2,*arg3);
83483     } catch (std::out_of_range& e) {
83484       {
83485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83486       };
83487     } catch (std::exception& e) {
83488       {
83489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83490       };
83491     } catch (Dali::DaliException e) {
83492       {
83493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83494       };
83495     } catch (...) {
83496       {
83497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83498       };
83499     }
83500   }
83501
83502 }
83503
83504
83505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83506   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83507   unsigned int arg2 ;
83508
83509   arg1 = (Dali::Toolkit::TableView *)jarg1;
83510   arg2 = (unsigned int)jarg2;
83511   {
83512     try {
83513       (arg1)->InsertColumn(arg2);
83514     } catch (std::out_of_range& e) {
83515       {
83516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83517       };
83518     } catch (std::exception& e) {
83519       {
83520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83521       };
83522     } catch (Dali::DaliException e) {
83523       {
83524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83525       };
83526     } catch (...) {
83527       {
83528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83529       };
83530     }
83531   }
83532
83533 }
83534
83535
83536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83537   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83538   unsigned int arg2 ;
83539
83540   arg1 = (Dali::Toolkit::TableView *)jarg1;
83541   arg2 = (unsigned int)jarg2;
83542   {
83543     try {
83544       (arg1)->DeleteColumn(arg2);
83545     } catch (std::out_of_range& e) {
83546       {
83547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83548       };
83549     } catch (std::exception& e) {
83550       {
83551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83552       };
83553     } catch (Dali::DaliException e) {
83554       {
83555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83556       };
83557     } catch (...) {
83558       {
83559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83560       };
83561     }
83562   }
83563
83564 }
83565
83566
83567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83568   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83569   unsigned int arg2 ;
83570   std::vector< Dali::Actor > *arg3 = 0 ;
83571
83572   arg1 = (Dali::Toolkit::TableView *)jarg1;
83573   arg2 = (unsigned int)jarg2;
83574   arg3 = (std::vector< Dali::Actor > *)jarg3;
83575   if (!arg3) {
83576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83577     return ;
83578   }
83579   {
83580     try {
83581       (arg1)->DeleteColumn(arg2,*arg3);
83582     } catch (std::out_of_range& e) {
83583       {
83584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83585       };
83586     } catch (std::exception& e) {
83587       {
83588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83589       };
83590     } catch (Dali::DaliException e) {
83591       {
83592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83593       };
83594     } catch (...) {
83595       {
83596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83597       };
83598     }
83599   }
83600
83601 }
83602
83603
83604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83605   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83606   unsigned int arg2 ;
83607   unsigned int arg3 ;
83608
83609   arg1 = (Dali::Toolkit::TableView *)jarg1;
83610   arg2 = (unsigned int)jarg2;
83611   arg3 = (unsigned int)jarg3;
83612   {
83613     try {
83614       (arg1)->Resize(arg2,arg3);
83615     } catch (std::out_of_range& e) {
83616       {
83617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83618       };
83619     } catch (std::exception& e) {
83620       {
83621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83622       };
83623     } catch (Dali::DaliException e) {
83624       {
83625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83626       };
83627     } catch (...) {
83628       {
83629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83630       };
83631     }
83632   }
83633
83634 }
83635
83636
83637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83638   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83639   unsigned int arg2 ;
83640   unsigned int arg3 ;
83641   std::vector< Dali::Actor > *arg4 = 0 ;
83642
83643   arg1 = (Dali::Toolkit::TableView *)jarg1;
83644   arg2 = (unsigned int)jarg2;
83645   arg3 = (unsigned int)jarg3;
83646   arg4 = (std::vector< Dali::Actor > *)jarg4;
83647   if (!arg4) {
83648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83649     return ;
83650   }
83651   {
83652     try {
83653       (arg1)->Resize(arg2,arg3,*arg4);
83654     } catch (std::out_of_range& e) {
83655       {
83656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83657       };
83658     } catch (std::exception& e) {
83659       {
83660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83661       };
83662     } catch (Dali::DaliException e) {
83663       {
83664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83665       };
83666     } catch (...) {
83667       {
83668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83669       };
83670     }
83671   }
83672
83673 }
83674
83675
83676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83677   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83678   Dali::Size arg2 ;
83679   Dali::Size *argp2 ;
83680
83681   arg1 = (Dali::Toolkit::TableView *)jarg1;
83682   argp2 = (Dali::Size *)jarg2;
83683   if (!argp2) {
83684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83685     return ;
83686   }
83687   arg2 = *argp2;
83688   {
83689     try {
83690       (arg1)->SetCellPadding(arg2);
83691     } catch (std::out_of_range& e) {
83692       {
83693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83694       };
83695     } catch (std::exception& e) {
83696       {
83697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83698       };
83699     } catch (Dali::DaliException e) {
83700       {
83701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83702       };
83703     } catch (...) {
83704       {
83705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83706       };
83707     }
83708   }
83709
83710 }
83711
83712
83713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83714   void * jresult ;
83715   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83716   Dali::Size result;
83717
83718   arg1 = (Dali::Toolkit::TableView *)jarg1;
83719   {
83720     try {
83721       result = (arg1)->GetCellPadding();
83722     } catch (std::out_of_range& e) {
83723       {
83724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83725       };
83726     } catch (std::exception& e) {
83727       {
83728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83729       };
83730     } catch (Dali::DaliException e) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83733       };
83734     } catch (...) {
83735       {
83736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83737       };
83738     }
83739   }
83740
83741   jresult = new Dali::Size((const Dali::Size &)result);
83742   return jresult;
83743 }
83744
83745
83746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83747   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83748   unsigned int arg2 ;
83749
83750   arg1 = (Dali::Toolkit::TableView *)jarg1;
83751   arg2 = (unsigned int)jarg2;
83752   {
83753     try {
83754       (arg1)->SetFitHeight(arg2);
83755     } catch (std::out_of_range& e) {
83756       {
83757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83758       };
83759     } catch (std::exception& e) {
83760       {
83761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83762       };
83763     } catch (Dali::DaliException e) {
83764       {
83765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83766       };
83767     } catch (...) {
83768       {
83769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83770       };
83771     }
83772   }
83773
83774 }
83775
83776
83777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83778   unsigned int jresult ;
83779   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83780   unsigned int arg2 ;
83781   bool result;
83782
83783   arg1 = (Dali::Toolkit::TableView *)jarg1;
83784   arg2 = (unsigned int)jarg2;
83785   {
83786     try {
83787       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83788     } catch (std::out_of_range& e) {
83789       {
83790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83791       };
83792     } catch (std::exception& e) {
83793       {
83794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83795       };
83796     } catch (Dali::DaliException e) {
83797       {
83798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83799       };
83800     } catch (...) {
83801       {
83802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83803       };
83804     }
83805   }
83806
83807   jresult = result;
83808   return jresult;
83809 }
83810
83811
83812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83813   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83814   unsigned int arg2 ;
83815
83816   arg1 = (Dali::Toolkit::TableView *)jarg1;
83817   arg2 = (unsigned int)jarg2;
83818   {
83819     try {
83820       (arg1)->SetFitWidth(arg2);
83821     } catch (std::out_of_range& e) {
83822       {
83823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83824       };
83825     } catch (std::exception& e) {
83826       {
83827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83828       };
83829     } catch (Dali::DaliException e) {
83830       {
83831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83832       };
83833     } catch (...) {
83834       {
83835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83836       };
83837     }
83838   }
83839
83840 }
83841
83842
83843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83844   unsigned int jresult ;
83845   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83846   unsigned int arg2 ;
83847   bool result;
83848
83849   arg1 = (Dali::Toolkit::TableView *)jarg1;
83850   arg2 = (unsigned int)jarg2;
83851   {
83852     try {
83853       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83854     } catch (std::out_of_range& e) {
83855       {
83856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83857       };
83858     } catch (std::exception& e) {
83859       {
83860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83861       };
83862     } catch (Dali::DaliException e) {
83863       {
83864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83865       };
83866     } catch (...) {
83867       {
83868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83869       };
83870     }
83871   }
83872
83873   jresult = result;
83874   return jresult;
83875 }
83876
83877
83878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83879   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83880   unsigned int arg2 ;
83881   float arg3 ;
83882
83883   arg1 = (Dali::Toolkit::TableView *)jarg1;
83884   arg2 = (unsigned int)jarg2;
83885   arg3 = (float)jarg3;
83886   {
83887     try {
83888       (arg1)->SetFixedHeight(arg2,arg3);
83889     } catch (std::out_of_range& e) {
83890       {
83891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83892       };
83893     } catch (std::exception& e) {
83894       {
83895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83896       };
83897     } catch (Dali::DaliException e) {
83898       {
83899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83900       };
83901     } catch (...) {
83902       {
83903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83904       };
83905     }
83906   }
83907
83908 }
83909
83910
83911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83912   float jresult ;
83913   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83914   unsigned int arg2 ;
83915   float result;
83916
83917   arg1 = (Dali::Toolkit::TableView *)jarg1;
83918   arg2 = (unsigned int)jarg2;
83919   {
83920     try {
83921       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83922     } catch (std::out_of_range& e) {
83923       {
83924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83925       };
83926     } catch (std::exception& e) {
83927       {
83928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83929       };
83930     } catch (Dali::DaliException e) {
83931       {
83932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83933       };
83934     } catch (...) {
83935       {
83936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83937       };
83938     }
83939   }
83940
83941   jresult = result;
83942   return jresult;
83943 }
83944
83945
83946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83947   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83948   unsigned int arg2 ;
83949   float arg3 ;
83950
83951   arg1 = (Dali::Toolkit::TableView *)jarg1;
83952   arg2 = (unsigned int)jarg2;
83953   arg3 = (float)jarg3;
83954   {
83955     try {
83956       (arg1)->SetRelativeHeight(arg2,arg3);
83957     } catch (std::out_of_range& e) {
83958       {
83959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83960       };
83961     } catch (std::exception& e) {
83962       {
83963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83964       };
83965     } catch (Dali::DaliException e) {
83966       {
83967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83968       };
83969     } catch (...) {
83970       {
83971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83972       };
83973     }
83974   }
83975
83976 }
83977
83978
83979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83980   float jresult ;
83981   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83982   unsigned int arg2 ;
83983   float result;
83984
83985   arg1 = (Dali::Toolkit::TableView *)jarg1;
83986   arg2 = (unsigned int)jarg2;
83987   {
83988     try {
83989       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83990     } catch (std::out_of_range& e) {
83991       {
83992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83993       };
83994     } catch (std::exception& e) {
83995       {
83996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83997       };
83998     } catch (Dali::DaliException e) {
83999       {
84000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84001       };
84002     } catch (...) {
84003       {
84004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84005       };
84006     }
84007   }
84008
84009   jresult = result;
84010   return jresult;
84011 }
84012
84013
84014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84015   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84016   unsigned int arg2 ;
84017   float arg3 ;
84018
84019   arg1 = (Dali::Toolkit::TableView *)jarg1;
84020   arg2 = (unsigned int)jarg2;
84021   arg3 = (float)jarg3;
84022   {
84023     try {
84024       (arg1)->SetFixedWidth(arg2,arg3);
84025     } catch (std::out_of_range& e) {
84026       {
84027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84028       };
84029     } catch (std::exception& e) {
84030       {
84031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84032       };
84033     } catch (Dali::DaliException e) {
84034       {
84035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84036       };
84037     } catch (...) {
84038       {
84039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84040       };
84041     }
84042   }
84043
84044 }
84045
84046
84047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84048   float jresult ;
84049   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84050   unsigned int arg2 ;
84051   float result;
84052
84053   arg1 = (Dali::Toolkit::TableView *)jarg1;
84054   arg2 = (unsigned int)jarg2;
84055   {
84056     try {
84057       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84058     } catch (std::out_of_range& e) {
84059       {
84060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84061       };
84062     } catch (std::exception& e) {
84063       {
84064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84065       };
84066     } catch (Dali::DaliException e) {
84067       {
84068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84069       };
84070     } catch (...) {
84071       {
84072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84073       };
84074     }
84075   }
84076
84077   jresult = result;
84078   return jresult;
84079 }
84080
84081
84082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84083   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84084   unsigned int arg2 ;
84085   float arg3 ;
84086
84087   arg1 = (Dali::Toolkit::TableView *)jarg1;
84088   arg2 = (unsigned int)jarg2;
84089   arg3 = (float)jarg3;
84090   {
84091     try {
84092       (arg1)->SetRelativeWidth(arg2,arg3);
84093     } catch (std::out_of_range& e) {
84094       {
84095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84096       };
84097     } catch (std::exception& e) {
84098       {
84099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84100       };
84101     } catch (Dali::DaliException e) {
84102       {
84103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84104       };
84105     } catch (...) {
84106       {
84107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84108       };
84109     }
84110   }
84111
84112 }
84113
84114
84115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84116   float jresult ;
84117   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84118   unsigned int arg2 ;
84119   float result;
84120
84121   arg1 = (Dali::Toolkit::TableView *)jarg1;
84122   arg2 = (unsigned int)jarg2;
84123   {
84124     try {
84125       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84126     } catch (std::out_of_range& e) {
84127       {
84128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84129       };
84130     } catch (std::exception& e) {
84131       {
84132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84133       };
84134     } catch (Dali::DaliException e) {
84135       {
84136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84137       };
84138     } catch (...) {
84139       {
84140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84141       };
84142     }
84143   }
84144
84145   jresult = result;
84146   return jresult;
84147 }
84148
84149
84150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84151   unsigned int jresult ;
84152   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84153   unsigned int result;
84154
84155   arg1 = (Dali::Toolkit::TableView *)jarg1;
84156   {
84157     try {
84158       result = (unsigned int)(arg1)->GetRows();
84159     } catch (std::out_of_range& e) {
84160       {
84161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84162       };
84163     } catch (std::exception& e) {
84164       {
84165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84166       };
84167     } catch (Dali::DaliException e) {
84168       {
84169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84170       };
84171     } catch (...) {
84172       {
84173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84174       };
84175     }
84176   }
84177
84178   jresult = result;
84179   return jresult;
84180 }
84181
84182
84183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84184   unsigned int jresult ;
84185   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84186   unsigned int result;
84187
84188   arg1 = (Dali::Toolkit::TableView *)jarg1;
84189   {
84190     try {
84191       result = (unsigned int)(arg1)->GetColumns();
84192     } catch (std::out_of_range& e) {
84193       {
84194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84195       };
84196     } catch (std::exception& e) {
84197       {
84198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84199       };
84200     } catch (Dali::DaliException e) {
84201       {
84202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84203       };
84204     } catch (...) {
84205       {
84206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84207       };
84208     }
84209   }
84210
84211   jresult = result;
84212   return jresult;
84213 }
84214
84215
84216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84217   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84218   Dali::Toolkit::TableView::CellPosition arg2 ;
84219   Dali::HorizontalAlignment::Type arg3 ;
84220   Dali::VerticalAlignment::Type arg4 ;
84221   Dali::Toolkit::TableView::CellPosition *argp2 ;
84222
84223   arg1 = (Dali::Toolkit::TableView *)jarg1;
84224   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84225   if (!argp2) {
84226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84227     return ;
84228   }
84229   arg2 = *argp2;
84230   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84231   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84232   {
84233     try {
84234       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84235     } catch (std::out_of_range& e) {
84236       {
84237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84238       };
84239     } catch (std::exception& e) {
84240       {
84241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84242       };
84243     } catch (Dali::DaliException e) {
84244       {
84245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84246       };
84247     } catch (...) {
84248       {
84249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84250       };
84251     }
84252   }
84253
84254 }
84255
84256
84257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84258   unsigned int jresult ;
84259   unsigned int result;
84260
84261   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84262   jresult = result;
84263   return jresult;
84264 }
84265
84266
84267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84268   int jresult ;
84269   int result;
84270
84271   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84272   jresult = (int)result;
84273   return jresult;
84274 }
84275
84276
84277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84278   int jresult ;
84279   int result;
84280
84281   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84282   jresult = (int)result;
84283   return jresult;
84284 }
84285
84286
84287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84288   int jresult ;
84289   int result;
84290
84291   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84292   jresult = (int)result;
84293   return jresult;
84294 }
84295
84296
84297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84298   int jresult ;
84299   int result;
84300
84301   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84302   jresult = (int)result;
84303   return jresult;
84304 }
84305
84306
84307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84308   int jresult ;
84309   int result;
84310
84311   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84312   jresult = (int)result;
84313   return jresult;
84314 }
84315
84316
84317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84318   int jresult ;
84319   int result;
84320
84321   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84322   jresult = (int)result;
84323   return jresult;
84324 }
84325
84326
84327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84328   int jresult ;
84329   int result;
84330
84331   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84332   jresult = (int)result;
84333   return jresult;
84334 }
84335
84336
84337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84338   int jresult ;
84339   int result;
84340
84341   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84342   jresult = (int)result;
84343   return jresult;
84344 }
84345
84346
84347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84348   int jresult ;
84349   int result;
84350
84351   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84352   jresult = (int)result;
84353   return jresult;
84354 }
84355
84356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84357   int jresult ;
84358   int result;
84359
84360   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84361   jresult = (int)result;
84362   return jresult;
84363 }
84364
84365
84366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84367   int jresult ;
84368   int result;
84369
84370   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84371   jresult = (int)result;
84372   return jresult;
84373 }
84374
84375
84376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84377   int jresult ;
84378   int result;
84379
84380   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84381   jresult = (int)result;
84382   return jresult;
84383 }
84384
84385
84386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84387   int jresult ;
84388   int result;
84389
84390   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84391   jresult = (int)result;
84392   return jresult;
84393 }
84394
84395
84396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84397   int jresult ;
84398   int result;
84399
84400   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84401   jresult = (int)result;
84402   return jresult;
84403 }
84404
84405
84406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84407   int jresult ;
84408   int result;
84409
84410   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84411   jresult = (int)result;
84412   return jresult;
84413 }
84414
84415
84416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84417   int jresult ;
84418   int result;
84419
84420   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84421   jresult = (int)result;
84422   return jresult;
84423 }
84424
84425
84426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84427   int jresult ;
84428   int result;
84429
84430   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84431   jresult = (int)result;
84432   return jresult;
84433 }
84434
84435
84436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84437   int jresult ;
84438   int result;
84439
84440   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84441   jresult = (int)result;
84442   return jresult;
84443 }
84444
84445
84446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84447   int jresult ;
84448   int result;
84449
84450   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84451   jresult = (int)result;
84452   return jresult;
84453 }
84454
84455
84456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84457   int jresult ;
84458   int result;
84459
84460   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84461   jresult = (int)result;
84462   return jresult;
84463 }
84464
84465
84466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84467   int jresult ;
84468   int result;
84469
84470   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84471   jresult = (int)result;
84472   return jresult;
84473 }
84474
84475
84476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84477   int jresult ;
84478   int result;
84479
84480   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84481   jresult = (int)result;
84482   return jresult;
84483 }
84484
84485
84486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84487   int jresult ;
84488   int result;
84489
84490   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84491   jresult = (int)result;
84492   return jresult;
84493 }
84494
84495
84496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84497   int jresult ;
84498   int result;
84499
84500   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84501   jresult = (int)result;
84502   return jresult;
84503 }
84504
84505
84506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84507   void * jresult ;
84508   Dali::Toolkit::TextLabel::Property *result = 0 ;
84509
84510   {
84511     try {
84512       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84513     } catch (std::out_of_range& e) {
84514       {
84515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84516       };
84517     } catch (std::exception& e) {
84518       {
84519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84520       };
84521     } catch (Dali::DaliException e) {
84522       {
84523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84524       };
84525     } catch (...) {
84526       {
84527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84528       };
84529     }
84530   }
84531
84532   jresult = (void *)result;
84533   return jresult;
84534 }
84535
84536
84537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84538   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84539
84540   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84541   {
84542     try {
84543       delete arg1;
84544     } catch (std::out_of_range& e) {
84545       {
84546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84547       };
84548     } catch (std::exception& e) {
84549       {
84550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84551       };
84552     } catch (Dali::DaliException e) {
84553       {
84554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84555       };
84556     } catch (...) {
84557       {
84558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84559       };
84560     }
84561   }
84562
84563 }
84564
84565
84566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84567   void * jresult ;
84568   Dali::Toolkit::TextLabel result;
84569
84570   {
84571     try {
84572       result = Dali::Toolkit::TextLabel::New();
84573     } catch (std::out_of_range& e) {
84574       {
84575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84576       };
84577     } catch (std::exception& e) {
84578       {
84579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84580       };
84581     } catch (Dali::DaliException e) {
84582       {
84583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84584       };
84585     } catch (...) {
84586       {
84587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84588       };
84589     }
84590   }
84591
84592   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84593   return jresult;
84594 }
84595
84596
84597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84598   void * jresult ;
84599   std::string *arg1 = 0 ;
84600   Dali::Toolkit::TextLabel result;
84601
84602   if (!jarg1) {
84603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84604     return 0;
84605   }
84606   std::string arg1_str(jarg1);
84607   arg1 = &arg1_str;
84608   {
84609     try {
84610       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84611     } catch (std::out_of_range& e) {
84612       {
84613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84614       };
84615     } catch (std::exception& e) {
84616       {
84617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84618       };
84619     } catch (Dali::DaliException e) {
84620       {
84621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84622       };
84623     } catch (...) {
84624       {
84625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84626       };
84627     }
84628   }
84629
84630   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84631
84632   //argout typemap for const std::string&
84633
84634   return jresult;
84635 }
84636
84637
84638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84639   void * jresult ;
84640   Dali::Toolkit::TextLabel *result = 0 ;
84641
84642   {
84643     try {
84644       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84645     } catch (std::out_of_range& e) {
84646       {
84647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84648       };
84649     } catch (std::exception& e) {
84650       {
84651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84652       };
84653     } catch (Dali::DaliException e) {
84654       {
84655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84656       };
84657     } catch (...) {
84658       {
84659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84660       };
84661     }
84662   }
84663
84664   jresult = (void *)result;
84665   return jresult;
84666 }
84667
84668
84669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84670   void * jresult ;
84671   Dali::Toolkit::TextLabel *arg1 = 0 ;
84672   Dali::Toolkit::TextLabel *result = 0 ;
84673
84674   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84675   if (!arg1) {
84676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84677     return 0;
84678   }
84679   {
84680     try {
84681       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84682     } catch (std::out_of_range& e) {
84683       {
84684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84685       };
84686     } catch (std::exception& e) {
84687       {
84688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84689       };
84690     } catch (Dali::DaliException e) {
84691       {
84692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84693       };
84694     } catch (...) {
84695       {
84696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84697       };
84698     }
84699   }
84700
84701   jresult = (void *)result;
84702   return jresult;
84703 }
84704
84705
84706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84707   void * jresult ;
84708   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84709   Dali::Toolkit::TextLabel *arg2 = 0 ;
84710   Dali::Toolkit::TextLabel *result = 0 ;
84711
84712   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84713   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84714   if (!arg2) {
84715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84716     return 0;
84717   }
84718   {
84719     try {
84720       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84721     } catch (std::out_of_range& e) {
84722       {
84723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84724       };
84725     } catch (std::exception& e) {
84726       {
84727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84728       };
84729     } catch (Dali::DaliException e) {
84730       {
84731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84732       };
84733     } catch (...) {
84734       {
84735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84736       };
84737     }
84738   }
84739
84740   jresult = (void *)result;
84741   return jresult;
84742 }
84743
84744
84745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84746   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84747
84748   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84749   {
84750     try {
84751       delete arg1;
84752     } catch (std::out_of_range& e) {
84753       {
84754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84755       };
84756     } catch (std::exception& e) {
84757       {
84758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84759       };
84760     } catch (Dali::DaliException e) {
84761       {
84762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84763       };
84764     } catch (...) {
84765       {
84766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84767       };
84768     }
84769   }
84770
84771 }
84772
84773
84774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84775   void * jresult ;
84776   Dali::BaseHandle arg1 ;
84777   Dali::BaseHandle *argp1 ;
84778   Dali::Toolkit::TextLabel result;
84779
84780   argp1 = (Dali::BaseHandle *)jarg1;
84781   if (!argp1) {
84782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84783     return 0;
84784   }
84785   arg1 = *argp1;
84786   {
84787     try {
84788       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84789     } catch (std::out_of_range& e) {
84790       {
84791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84792       };
84793     } catch (std::exception& e) {
84794       {
84795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84796       };
84797     } catch (Dali::DaliException e) {
84798       {
84799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84800       };
84801     } catch (...) {
84802       {
84803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84804       };
84805     }
84806   }
84807
84808   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84809   return jresult;
84810 }
84811
84812
84813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84814   void * jresult ;
84815   Dali::Toolkit::AccessibilityManager *result = 0 ;
84816
84817   {
84818     try {
84819       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84820     } catch (std::out_of_range& e) {
84821       {
84822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84823       };
84824     } catch (std::exception& e) {
84825       {
84826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84827       };
84828     } catch (Dali::DaliException e) {
84829       {
84830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84831       };
84832     } catch (...) {
84833       {
84834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84835       };
84836     }
84837   }
84838
84839   jresult = (void *)result;
84840   return jresult;
84841 }
84842
84843
84844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84845   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84846
84847   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84848   {
84849     try {
84850       delete arg1;
84851     } catch (std::out_of_range& e) {
84852       {
84853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84854       };
84855     } catch (std::exception& e) {
84856       {
84857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84858       };
84859     } catch (Dali::DaliException e) {
84860       {
84861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84862       };
84863     } catch (...) {
84864       {
84865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84866       };
84867     }
84868   }
84869
84870 }
84871
84872
84873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84874   void * jresult ;
84875   Dali::Toolkit::AccessibilityManager result;
84876
84877   {
84878     try {
84879       result = Dali::Toolkit::AccessibilityManager::Get();
84880     } catch (std::out_of_range& e) {
84881       {
84882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (std::exception& e) {
84885       {
84886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84887       };
84888     } catch (Dali::DaliException e) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84891       };
84892     } catch (...) {
84893       {
84894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84895       };
84896     }
84897   }
84898
84899   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84900   return jresult;
84901 }
84902
84903
84904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84906   Dali::Actor arg2 ;
84907   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84908   std::string *arg4 = 0 ;
84909   Dali::Actor *argp2 ;
84910
84911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84912   argp2 = (Dali::Actor *)jarg2;
84913   if (!argp2) {
84914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84915     return ;
84916   }
84917   arg2 = *argp2;
84918   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84919   if (!jarg4) {
84920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84921     return ;
84922   }
84923   std::string arg4_str(jarg4);
84924   arg4 = &arg4_str;
84925   {
84926     try {
84927       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84928     } catch (std::out_of_range& e) {
84929       {
84930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84931       };
84932     } catch (std::exception& e) {
84933       {
84934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84935       };
84936     } catch (Dali::DaliException e) {
84937       {
84938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84939       };
84940     } catch (...) {
84941       {
84942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84943       };
84944     }
84945   }
84946
84947
84948   //argout typemap for const std::string&
84949
84950 }
84951
84952
84953 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84954   char * jresult ;
84955   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84956   Dali::Actor arg2 ;
84957   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84958   Dali::Actor *argp2 ;
84959   std::string result;
84960
84961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84962   argp2 = (Dali::Actor *)jarg2;
84963   if (!argp2) {
84964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84965     return 0;
84966   }
84967   arg2 = *argp2;
84968   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84969   {
84970     try {
84971       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84972     } catch (std::out_of_range& e) {
84973       {
84974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84975       };
84976     } catch (std::exception& e) {
84977       {
84978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84979       };
84980     } catch (Dali::DaliException e) {
84981       {
84982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84983       };
84984     } catch (...) {
84985       {
84986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84987       };
84988     }
84989   }
84990
84991   jresult = SWIG_csharp_string_callback((&result)->c_str());
84992   return jresult;
84993 }
84994
84995
84996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84997   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84998   Dali::Actor arg2 ;
84999   unsigned int arg3 ;
85000   Dali::Actor *argp2 ;
85001
85002   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85003   argp2 = (Dali::Actor *)jarg2;
85004   if (!argp2) {
85005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85006     return ;
85007   }
85008   arg2 = *argp2;
85009   arg3 = (unsigned int)jarg3;
85010   {
85011     try {
85012       (arg1)->SetFocusOrder(arg2,arg3);
85013     } catch (std::out_of_range& e) {
85014       {
85015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85016       };
85017     } catch (std::exception& e) {
85018       {
85019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85020       };
85021     } catch (Dali::DaliException e) {
85022       {
85023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85024       };
85025     } catch (...) {
85026       {
85027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85028       };
85029     }
85030   }
85031
85032 }
85033
85034
85035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85036   unsigned int jresult ;
85037   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85038   Dali::Actor arg2 ;
85039   Dali::Actor *argp2 ;
85040   unsigned int result;
85041
85042   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85043   argp2 = (Dali::Actor *)jarg2;
85044   if (!argp2) {
85045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85046     return 0;
85047   }
85048   arg2 = *argp2;
85049   {
85050     try {
85051       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85052     } catch (std::out_of_range& e) {
85053       {
85054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (std::exception& e) {
85057       {
85058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85059       };
85060     } catch (Dali::DaliException e) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85063       };
85064     } catch (...) {
85065       {
85066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85067       };
85068     }
85069   }
85070
85071   jresult = result;
85072   return jresult;
85073 }
85074
85075
85076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85077   unsigned int jresult ;
85078   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85079   unsigned int result;
85080
85081   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85082   {
85083     try {
85084       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85085     } catch (std::out_of_range& e) {
85086       {
85087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85088       };
85089     } catch (std::exception& e) {
85090       {
85091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85092       };
85093     } catch (Dali::DaliException e) {
85094       {
85095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85096       };
85097     } catch (...) {
85098       {
85099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85100       };
85101     }
85102   }
85103
85104   jresult = result;
85105   return jresult;
85106 }
85107
85108
85109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85110   void * jresult ;
85111   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85112   unsigned int arg2 ;
85113   Dali::Actor result;
85114
85115   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85116   arg2 = (unsigned int)jarg2;
85117   {
85118     try {
85119       result = (arg1)->GetActorByFocusOrder(arg2);
85120     } catch (std::out_of_range& e) {
85121       {
85122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85123       };
85124     } catch (std::exception& e) {
85125       {
85126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85127       };
85128     } catch (Dali::DaliException e) {
85129       {
85130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85131       };
85132     } catch (...) {
85133       {
85134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85135       };
85136     }
85137   }
85138
85139   jresult = new Dali::Actor((const Dali::Actor &)result);
85140   return jresult;
85141 }
85142
85143
85144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85145   unsigned int jresult ;
85146   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85147   Dali::Actor arg2 ;
85148   Dali::Actor *argp2 ;
85149   bool result;
85150
85151   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85152   argp2 = (Dali::Actor *)jarg2;
85153   if (!argp2) {
85154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85155     return 0;
85156   }
85157   arg2 = *argp2;
85158   {
85159     try {
85160       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85161     } catch (std::out_of_range& e) {
85162       {
85163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85164       };
85165     } catch (std::exception& e) {
85166       {
85167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85168       };
85169     } catch (Dali::DaliException e) {
85170       {
85171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85172       };
85173     } catch (...) {
85174       {
85175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85176       };
85177     }
85178   }
85179
85180   jresult = result;
85181   return jresult;
85182 }
85183
85184
85185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85186   void * jresult ;
85187   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85188   Dali::Actor result;
85189
85190   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85191   {
85192     try {
85193       result = (arg1)->GetCurrentFocusActor();
85194     } catch (std::out_of_range& e) {
85195       {
85196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85197       };
85198     } catch (std::exception& e) {
85199       {
85200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85201       };
85202     } catch (Dali::DaliException e) {
85203       {
85204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85205       };
85206     } catch (...) {
85207       {
85208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85209       };
85210     }
85211   }
85212
85213   jresult = new Dali::Actor((const Dali::Actor &)result);
85214   return jresult;
85215 }
85216
85217
85218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85219   void * jresult ;
85220   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85221   Dali::Actor result;
85222
85223   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85224   {
85225     try {
85226       result = (arg1)->GetCurrentFocusGroup();
85227     } catch (std::out_of_range& e) {
85228       {
85229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85230       };
85231     } catch (std::exception& e) {
85232       {
85233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85234       };
85235     } catch (Dali::DaliException e) {
85236       {
85237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85238       };
85239     } catch (...) {
85240       {
85241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85242       };
85243     }
85244   }
85245
85246   jresult = new Dali::Actor((const Dali::Actor &)result);
85247   return jresult;
85248 }
85249
85250
85251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85252   unsigned int jresult ;
85253   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85254   unsigned int result;
85255
85256   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85257   {
85258     try {
85259       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85260     } catch (std::out_of_range& e) {
85261       {
85262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85263       };
85264     } catch (std::exception& e) {
85265       {
85266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85267       };
85268     } catch (Dali::DaliException e) {
85269       {
85270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85271       };
85272     } catch (...) {
85273       {
85274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85275       };
85276     }
85277   }
85278
85279   jresult = result;
85280   return jresult;
85281 }
85282
85283
85284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85285   unsigned int jresult ;
85286   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85287   bool result;
85288
85289   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85290   {
85291     try {
85292       result = (bool)(arg1)->MoveFocusForward();
85293     } catch (std::out_of_range& e) {
85294       {
85295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85296       };
85297     } catch (std::exception& e) {
85298       {
85299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85300       };
85301     } catch (Dali::DaliException e) {
85302       {
85303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85304       };
85305     } catch (...) {
85306       {
85307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85308       };
85309     }
85310   }
85311
85312   jresult = result;
85313   return jresult;
85314 }
85315
85316
85317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85318   unsigned int jresult ;
85319   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85320   bool result;
85321
85322   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85323   {
85324     try {
85325       result = (bool)(arg1)->MoveFocusBackward();
85326     } catch (std::out_of_range& e) {
85327       {
85328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85329       };
85330     } catch (std::exception& e) {
85331       {
85332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85333       };
85334     } catch (Dali::DaliException e) {
85335       {
85336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85337       };
85338     } catch (...) {
85339       {
85340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85341       };
85342     }
85343   }
85344
85345   jresult = result;
85346   return jresult;
85347 }
85348
85349
85350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85351   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85352
85353   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85354   {
85355     try {
85356       (arg1)->ClearFocus();
85357     } catch (std::out_of_range& e) {
85358       {
85359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85360       };
85361     } catch (std::exception& e) {
85362       {
85363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85364       };
85365     } catch (Dali::DaliException e) {
85366       {
85367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85368       };
85369     } catch (...) {
85370       {
85371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85372       };
85373     }
85374   }
85375
85376 }
85377
85378
85379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85380   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85381
85382   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85383   {
85384     try {
85385       (arg1)->Reset();
85386     } catch (std::out_of_range& e) {
85387       {
85388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85389       };
85390     } catch (std::exception& e) {
85391       {
85392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85393       };
85394     } catch (Dali::DaliException e) {
85395       {
85396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85397       };
85398     } catch (...) {
85399       {
85400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85401       };
85402     }
85403   }
85404
85405 }
85406
85407
85408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85409   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85410   Dali::Actor arg2 ;
85411   bool arg3 ;
85412   Dali::Actor *argp2 ;
85413
85414   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85415   argp2 = (Dali::Actor *)jarg2;
85416   if (!argp2) {
85417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85418     return ;
85419   }
85420   arg2 = *argp2;
85421   arg3 = jarg3 ? true : false;
85422   {
85423     try {
85424       (arg1)->SetFocusGroup(arg2,arg3);
85425     } catch (std::out_of_range& e) {
85426       {
85427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85428       };
85429     } catch (std::exception& e) {
85430       {
85431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85432       };
85433     } catch (Dali::DaliException e) {
85434       {
85435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85436       };
85437     } catch (...) {
85438       {
85439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85440       };
85441     }
85442   }
85443
85444 }
85445
85446
85447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85448   unsigned int jresult ;
85449   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85450   Dali::Actor arg2 ;
85451   Dali::Actor *argp2 ;
85452   bool result;
85453
85454   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85455   argp2 = (Dali::Actor *)jarg2;
85456   if (!argp2) {
85457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85458     return 0;
85459   }
85460   arg2 = *argp2;
85461   {
85462     try {
85463       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85464     } catch (std::out_of_range& e) {
85465       {
85466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85467       };
85468     } catch (std::exception& e) {
85469       {
85470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85471       };
85472     } catch (Dali::DaliException e) {
85473       {
85474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85475       };
85476     } catch (...) {
85477       {
85478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85479       };
85480     }
85481   }
85482
85483   jresult = result;
85484   return jresult;
85485 }
85486
85487
85488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85489   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85490   bool arg2 ;
85491
85492   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85493   arg2 = jarg2 ? true : false;
85494   {
85495     try {
85496       (arg1)->SetGroupMode(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 (Dali::DaliException e) {
85506       {
85507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85508       };
85509     } catch (...) {
85510       {
85511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85512       };
85513     }
85514   }
85515
85516 }
85517
85518
85519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85520   unsigned int jresult ;
85521   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85522   bool result;
85523
85524   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85525   {
85526     try {
85527       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85528     } catch (std::out_of_range& e) {
85529       {
85530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85531       };
85532     } catch (std::exception& e) {
85533       {
85534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85535       };
85536     } catch (Dali::DaliException e) {
85537       {
85538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85539       };
85540     } catch (...) {
85541       {
85542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85543       };
85544     }
85545   }
85546
85547   jresult = result;
85548   return jresult;
85549 }
85550
85551
85552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85553   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85554   bool arg2 ;
85555
85556   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85557   arg2 = jarg2 ? true : false;
85558   {
85559     try {
85560       (arg1)->SetWrapMode(arg2);
85561     } catch (std::out_of_range& e) {
85562       {
85563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85564       };
85565     } catch (std::exception& e) {
85566       {
85567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85568       };
85569     } catch (Dali::DaliException e) {
85570       {
85571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85572       };
85573     } catch (...) {
85574       {
85575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85576       };
85577     }
85578   }
85579
85580 }
85581
85582
85583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85584   unsigned int jresult ;
85585   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85586   bool result;
85587
85588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85589   {
85590     try {
85591       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85592     } catch (std::out_of_range& e) {
85593       {
85594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85595       };
85596     } catch (std::exception& e) {
85597       {
85598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85599       };
85600     } catch (Dali::DaliException e) {
85601       {
85602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85603       };
85604     } catch (...) {
85605       {
85606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85607       };
85608     }
85609   }
85610
85611   jresult = result;
85612   return jresult;
85613 }
85614
85615
85616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85618   Dali::Actor arg2 ;
85619   Dali::Actor *argp2 ;
85620
85621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85622   argp2 = (Dali::Actor *)jarg2;
85623   if (!argp2) {
85624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85625     return ;
85626   }
85627   arg2 = *argp2;
85628   {
85629     try {
85630       (arg1)->SetFocusIndicatorActor(arg2);
85631     } catch (std::out_of_range& e) {
85632       {
85633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85634       };
85635     } catch (std::exception& e) {
85636       {
85637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85638       };
85639     } catch (Dali::DaliException e) {
85640       {
85641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85642       };
85643     } catch (...) {
85644       {
85645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85646       };
85647     }
85648   }
85649
85650 }
85651
85652
85653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85654   void * jresult ;
85655   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85656   Dali::Actor result;
85657
85658   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85659   {
85660     try {
85661       result = (arg1)->GetFocusIndicatorActor();
85662     } catch (std::out_of_range& e) {
85663       {
85664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85665       };
85666     } catch (std::exception& e) {
85667       {
85668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85669       };
85670     } catch (Dali::DaliException e) {
85671       {
85672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85673       };
85674     } catch (...) {
85675       {
85676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85677       };
85678     }
85679   }
85680
85681   jresult = new Dali::Actor((const Dali::Actor &)result);
85682   return jresult;
85683 }
85684
85685
85686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85687   void * jresult ;
85688   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85689   Dali::Actor arg2 ;
85690   Dali::Actor *argp2 ;
85691   Dali::Actor result;
85692
85693   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85694   argp2 = (Dali::Actor *)jarg2;
85695   if (!argp2) {
85696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85697     return 0;
85698   }
85699   arg2 = *argp2;
85700   {
85701     try {
85702       result = (arg1)->GetFocusGroup(arg2);
85703     } catch (std::out_of_range& e) {
85704       {
85705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85706       };
85707     } catch (std::exception& e) {
85708       {
85709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85710       };
85711     } catch (Dali::DaliException e) {
85712       {
85713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85714       };
85715     } catch (...) {
85716       {
85717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85718       };
85719     }
85720   }
85721
85722   jresult = new Dali::Actor((const Dali::Actor &)result);
85723   return jresult;
85724 }
85725
85726
85727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85728   void * jresult ;
85729   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85730   Dali::Vector2 result;
85731
85732   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85733   {
85734     try {
85735       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85736     } catch (std::out_of_range& e) {
85737       {
85738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85739       };
85740     } catch (std::exception& e) {
85741       {
85742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85743       };
85744     } catch (Dali::DaliException e) {
85745       {
85746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85747       };
85748     } catch (...) {
85749       {
85750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85751       };
85752     }
85753   }
85754
85755   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85756   return jresult;
85757 }
85758
85759
85760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85761   void * jresult ;
85762   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85763   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85764
85765   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85766   {
85767     try {
85768       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85769     } catch (std::out_of_range& e) {
85770       {
85771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85772       };
85773     } catch (std::exception& e) {
85774       {
85775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85776       };
85777     } catch (Dali::DaliException e) {
85778       {
85779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85780       };
85781     } catch (...) {
85782       {
85783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85784       };
85785     }
85786   }
85787
85788   jresult = (void *)result;
85789   return jresult;
85790 }
85791
85792
85793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85794   void * jresult ;
85795   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85796   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85797
85798   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85799   {
85800     try {
85801       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85802     } catch (std::out_of_range& e) {
85803       {
85804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85805       };
85806     } catch (std::exception& e) {
85807       {
85808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85809       };
85810     } catch (Dali::DaliException e) {
85811       {
85812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85813       };
85814     } catch (...) {
85815       {
85816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85817       };
85818     }
85819   }
85820
85821   jresult = (void *)result;
85822   return jresult;
85823 }
85824
85825
85826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85827   void * jresult ;
85828   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85829   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85830
85831   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85832   {
85833     try {
85834       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85835     } catch (std::out_of_range& e) {
85836       {
85837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85838       };
85839     } catch (std::exception& e) {
85840       {
85841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85842       };
85843     } catch (Dali::DaliException e) {
85844       {
85845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85846       };
85847     } catch (...) {
85848       {
85849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85850       };
85851     }
85852   }
85853
85854   jresult = (void *)result;
85855   return jresult;
85856 }
85857
85858
85859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85860   void * jresult ;
85861   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85862   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85863
85864   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85865   {
85866     try {
85867       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85868     } catch (std::out_of_range& e) {
85869       {
85870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85871       };
85872     } catch (std::exception& e) {
85873       {
85874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85875       };
85876     } catch (Dali::DaliException e) {
85877       {
85878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85879       };
85880     } catch (...) {
85881       {
85882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85883       };
85884     }
85885   }
85886
85887   jresult = (void *)result;
85888   return jresult;
85889 }
85890
85891
85892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85893   void * jresult ;
85894   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85895   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85896
85897   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85898   {
85899     try {
85900       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85901     } catch (std::out_of_range& e) {
85902       {
85903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85904       };
85905     } catch (std::exception& e) {
85906       {
85907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85908       };
85909     } catch (Dali::DaliException e) {
85910       {
85911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85912       };
85913     } catch (...) {
85914       {
85915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85916       };
85917     }
85918   }
85919
85920   jresult = (void *)result;
85921   return jresult;
85922 }
85923
85924
85925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85926   void * jresult ;
85927   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85928   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85929
85930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85931   {
85932     try {
85933       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85934     } catch (std::out_of_range& e) {
85935       {
85936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85937       };
85938     } catch (std::exception& e) {
85939       {
85940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85941       };
85942     } catch (Dali::DaliException e) {
85943       {
85944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85945       };
85946     } catch (...) {
85947       {
85948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85949       };
85950     }
85951   }
85952
85953   jresult = (void *)result;
85954   return jresult;
85955 }
85956
85957
85958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85959   void * jresult ;
85960   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85961   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85962
85963   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85964   {
85965     try {
85966       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85967     } catch (std::out_of_range& e) {
85968       {
85969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85970       };
85971     } catch (std::exception& e) {
85972       {
85973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85974       };
85975     } catch (Dali::DaliException e) {
85976       {
85977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85978       };
85979     } catch (...) {
85980       {
85981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85982       };
85983     }
85984   }
85985
85986   jresult = (void *)result;
85987   return jresult;
85988 }
85989
85990
85991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85992   void * jresult ;
85993   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85994   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85995
85996   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85997   {
85998     try {
85999       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
86000     } catch (std::out_of_range& e) {
86001       {
86002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86003       };
86004     } catch (std::exception& e) {
86005       {
86006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86007       };
86008     } catch (Dali::DaliException e) {
86009       {
86010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86011       };
86012     } catch (...) {
86013       {
86014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86015       };
86016     }
86017   }
86018
86019   jresult = (void *)result;
86020   return jresult;
86021 }
86022
86023
86024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86025   void * jresult ;
86026   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86027   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86028
86029   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86030   {
86031     try {
86032       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
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 (Dali::DaliException e) {
86042       {
86043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86044       };
86045     } catch (...) {
86046       {
86047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86048       };
86049     }
86050   }
86051
86052   jresult = (void *)result;
86053   return jresult;
86054 }
86055
86056
86057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86058   void * jresult ;
86059   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86060   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86061
86062   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86063   {
86064     try {
86065       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86066     } catch (std::out_of_range& e) {
86067       {
86068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86069       };
86070     } catch (std::exception& e) {
86071       {
86072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86073       };
86074     } catch (Dali::DaliException e) {
86075       {
86076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86077       };
86078     } catch (...) {
86079       {
86080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86081       };
86082     }
86083   }
86084
86085   jresult = (void *)result;
86086   return jresult;
86087 }
86088
86089
86090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86091   void * jresult ;
86092   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86093   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86094
86095   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86096   {
86097     try {
86098       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86099     } catch (std::out_of_range& e) {
86100       {
86101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86102       };
86103     } catch (std::exception& e) {
86104       {
86105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86106       };
86107     } catch (Dali::DaliException e) {
86108       {
86109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86110       };
86111     } catch (...) {
86112       {
86113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86114       };
86115     }
86116   }
86117
86118   jresult = (void *)result;
86119   return jresult;
86120 }
86121
86122
86123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86124   void * jresult ;
86125   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86126   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86127
86128   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86129   {
86130     try {
86131       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86132     } catch (std::out_of_range& e) {
86133       {
86134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86135       };
86136     } catch (std::exception& e) {
86137       {
86138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86139       };
86140     } catch (Dali::DaliException e) {
86141       {
86142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86143       };
86144     } catch (...) {
86145       {
86146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86147       };
86148     }
86149   }
86150
86151   jresult = (void *)result;
86152   return jresult;
86153 }
86154
86155
86156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86157   void * jresult ;
86158   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86159   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86160
86161   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86162   {
86163     try {
86164       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86165     } catch (std::out_of_range& e) {
86166       {
86167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86168       };
86169     } catch (std::exception& e) {
86170       {
86171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86172       };
86173     } catch (Dali::DaliException e) {
86174       {
86175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86176       };
86177     } catch (...) {
86178       {
86179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86180       };
86181     }
86182   }
86183
86184   jresult = (void *)result;
86185   return jresult;
86186 }
86187
86188
86189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86190   void * jresult ;
86191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86192   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86193
86194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86195   {
86196     try {
86197       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86198     } catch (std::out_of_range& e) {
86199       {
86200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86201       };
86202     } catch (std::exception& e) {
86203       {
86204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86205       };
86206     } catch (Dali::DaliException e) {
86207       {
86208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86209       };
86210     } catch (...) {
86211       {
86212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86213       };
86214     }
86215   }
86216
86217   jresult = (void *)result;
86218   return jresult;
86219 }
86220
86221
86222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86223   void * jresult ;
86224   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86225   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86226
86227   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86228   {
86229     try {
86230       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86231     } catch (std::out_of_range& e) {
86232       {
86233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86234       };
86235     } catch (std::exception& e) {
86236       {
86237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86238       };
86239     } catch (Dali::DaliException e) {
86240       {
86241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86242       };
86243     } catch (...) {
86244       {
86245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86246       };
86247     }
86248   }
86249
86250   jresult = (void *)result;
86251   return jresult;
86252 }
86253
86254
86255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86256   void * jresult ;
86257   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86258   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86259
86260   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86261   {
86262     try {
86263       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86264     } catch (std::out_of_range& e) {
86265       {
86266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86267       };
86268     } catch (std::exception& e) {
86269       {
86270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86271       };
86272     } catch (Dali::DaliException e) {
86273       {
86274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86275       };
86276     } catch (...) {
86277       {
86278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86279       };
86280     }
86281   }
86282
86283   jresult = (void *)result;
86284   return jresult;
86285 }
86286
86287
86288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86289   void * jresult ;
86290   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86291   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86292
86293   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86294   {
86295     try {
86296       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
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 (Dali::DaliException e) {
86306       {
86307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86308       };
86309     } catch (...) {
86310       {
86311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86312       };
86313     }
86314   }
86315
86316   jresult = (void *)result;
86317   return jresult;
86318 }
86319
86320
86321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86322   void * jresult ;
86323   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86324   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86325
86326   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86327   {
86328     try {
86329       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86330     } catch (std::out_of_range& e) {
86331       {
86332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86333       };
86334     } catch (std::exception& e) {
86335       {
86336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86337       };
86338     } catch (Dali::DaliException e) {
86339       {
86340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86341       };
86342     } catch (...) {
86343       {
86344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86345       };
86346     }
86347   }
86348
86349   jresult = (void *)result;
86350   return jresult;
86351 }
86352
86353
86354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86355   void * jresult ;
86356   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86357   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86358
86359   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86360   {
86361     try {
86362       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86363     } catch (std::out_of_range& e) {
86364       {
86365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86366       };
86367     } catch (std::exception& e) {
86368       {
86369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86370       };
86371     } catch (Dali::DaliException e) {
86372       {
86373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86374       };
86375     } catch (...) {
86376       {
86377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86378       };
86379     }
86380   }
86381
86382   jresult = (void *)result;
86383   return jresult;
86384 }
86385
86386
86387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86388   void * jresult ;
86389   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86390   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86391
86392   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86393   {
86394     try {
86395       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86396     } catch (std::out_of_range& e) {
86397       {
86398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86399       };
86400     } catch (std::exception& e) {
86401       {
86402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86403       };
86404     } catch (Dali::DaliException e) {
86405       {
86406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86407       };
86408     } catch (...) {
86409       {
86410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86411       };
86412     }
86413   }
86414
86415   jresult = (void *)result;
86416   return jresult;
86417 }
86418
86419
86420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86421   void * jresult ;
86422   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86423   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86424
86425   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86426   {
86427     try {
86428       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86429     } catch (std::out_of_range& e) {
86430       {
86431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86432       };
86433     } catch (std::exception& e) {
86434       {
86435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86436       };
86437     } catch (Dali::DaliException e) {
86438       {
86439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86440       };
86441     } catch (...) {
86442       {
86443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86444       };
86445     }
86446   }
86447
86448   jresult = (void *)result;
86449   return jresult;
86450 }
86451
86452
86453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86454   void * jresult ;
86455   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86456   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86457
86458   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86459   {
86460     try {
86461       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86462     } catch (std::out_of_range& e) {
86463       {
86464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86465       };
86466     } catch (std::exception& e) {
86467       {
86468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86469       };
86470     } catch (Dali::DaliException e) {
86471       {
86472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86473       };
86474     } catch (...) {
86475       {
86476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86477       };
86478     }
86479   }
86480
86481   jresult = (void *)result;
86482   return jresult;
86483 }
86484
86485
86486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86487   void * jresult ;
86488   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86489   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86490
86491   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86492   {
86493     try {
86494       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86495     } catch (std::out_of_range& e) {
86496       {
86497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86498       };
86499     } catch (std::exception& e) {
86500       {
86501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86502       };
86503     } catch (Dali::DaliException e) {
86504       {
86505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86506       };
86507     } catch (...) {
86508       {
86509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86510       };
86511     }
86512   }
86513
86514   jresult = (void *)result;
86515   return jresult;
86516 }
86517
86518
86519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86520   void * jresult ;
86521   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86522   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86523
86524   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86525   {
86526     try {
86527       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86528     } catch (std::out_of_range& e) {
86529       {
86530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86531       };
86532     } catch (std::exception& e) {
86533       {
86534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86535       };
86536     } catch (Dali::DaliException e) {
86537       {
86538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86539       };
86540     } catch (...) {
86541       {
86542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86543       };
86544     }
86545   }
86546
86547   jresult = (void *)result;
86548   return jresult;
86549 }
86550
86551
86552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86553   void * jresult ;
86554   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86555   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86556
86557   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86558   {
86559     try {
86560       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86561     } catch (std::out_of_range& e) {
86562       {
86563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86564       };
86565     } catch (std::exception& e) {
86566       {
86567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86568       };
86569     } catch (Dali::DaliException e) {
86570       {
86571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86572       };
86573     } catch (...) {
86574       {
86575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86576       };
86577     }
86578   }
86579
86580   jresult = (void *)result;
86581   return jresult;
86582 }
86583
86584
86585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86586   void * jresult ;
86587   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86588   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86589
86590   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86591   {
86592     try {
86593       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86594     } catch (std::out_of_range& e) {
86595       {
86596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86597       };
86598     } catch (std::exception& e) {
86599       {
86600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86601       };
86602     } catch (Dali::DaliException e) {
86603       {
86604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86605       };
86606     } catch (...) {
86607       {
86608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86609       };
86610     }
86611   }
86612
86613   jresult = (void *)result;
86614   return jresult;
86615 }
86616
86617
86618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86619   void * jresult ;
86620   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86621   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86622
86623   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86624   {
86625     try {
86626       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86627     } catch (std::out_of_range& e) {
86628       {
86629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86630       };
86631     } catch (std::exception& e) {
86632       {
86633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86634       };
86635     } catch (Dali::DaliException e) {
86636       {
86637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86638       };
86639     } catch (...) {
86640       {
86641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86642       };
86643     }
86644   }
86645
86646   jresult = (void *)result;
86647   return jresult;
86648 }
86649
86650
86651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86652   void * jresult ;
86653   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86654   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86655
86656   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86657   {
86658     try {
86659       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86660     } catch (std::out_of_range& e) {
86661       {
86662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86663       };
86664     } catch (std::exception& e) {
86665       {
86666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86667       };
86668     } catch (Dali::DaliException e) {
86669       {
86670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86671       };
86672     } catch (...) {
86673       {
86674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86675       };
86676     }
86677   }
86678
86679   jresult = (void *)result;
86680   return jresult;
86681 }
86682
86683
86684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86685   void * jresult ;
86686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86687   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86688
86689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86690   {
86691     try {
86692       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86693     } catch (std::out_of_range& e) {
86694       {
86695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86696       };
86697     } catch (std::exception& e) {
86698       {
86699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86700       };
86701     } catch (Dali::DaliException e) {
86702       {
86703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86704       };
86705     } catch (...) {
86706       {
86707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86708       };
86709     }
86710   }
86711
86712   jresult = (void *)result;
86713   return jresult;
86714 }
86715
86716
86717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86718   void * jresult ;
86719   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86720   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86721
86722   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86723   {
86724     try {
86725       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86726     } catch (std::out_of_range& e) {
86727       {
86728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86729       };
86730     } catch (std::exception& e) {
86731       {
86732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86733       };
86734     } catch (Dali::DaliException e) {
86735       {
86736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86737       };
86738     } catch (...) {
86739       {
86740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86741       };
86742     }
86743   }
86744
86745   jresult = (void *)result;
86746   return jresult;
86747 }
86748
86749
86750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86751   void * jresult ;
86752   Dali::Toolkit::StyleManager *result = 0 ;
86753
86754   {
86755     try {
86756       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86757     } catch (std::out_of_range& e) {
86758       {
86759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86760       };
86761     } catch (std::exception& e) {
86762       {
86763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86764       };
86765     } catch (Dali::DaliException e) {
86766       {
86767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86768       };
86769     } catch (...) {
86770       {
86771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86772       };
86773     }
86774   }
86775
86776   jresult = (void *)result;
86777   return jresult;
86778 }
86779
86780
86781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86782   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86783
86784   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86785   {
86786     try {
86787       delete arg1;
86788     } catch (std::out_of_range& e) {
86789       {
86790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86791       };
86792     } catch (std::exception& e) {
86793       {
86794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86795       };
86796     } catch (Dali::DaliException e) {
86797       {
86798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86799       };
86800     } catch (...) {
86801       {
86802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86803       };
86804     }
86805   }
86806
86807 }
86808
86809
86810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86811   void * jresult ;
86812   Dali::Toolkit::StyleManager result;
86813
86814   {
86815     try {
86816       result = Dali::Toolkit::StyleManager::Get();
86817     } catch (std::out_of_range& e) {
86818       {
86819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86820       };
86821     } catch (std::exception& e) {
86822       {
86823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86824       };
86825     } catch (Dali::DaliException e) {
86826       {
86827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86828       };
86829     } catch (...) {
86830       {
86831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86832       };
86833     }
86834   }
86835
86836   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86837   return jresult;
86838 }
86839
86840
86841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86842   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86843   std::string *arg2 = 0 ;
86844
86845   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86846   if (!jarg2) {
86847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86848     return ;
86849   }
86850   std::string arg2_str(jarg2);
86851   arg2 = &arg2_str;
86852   {
86853     try {
86854       (arg1)->ApplyTheme((std::string const &)*arg2);
86855     } catch (std::out_of_range& e) {
86856       {
86857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86858       };
86859     } catch (std::exception& e) {
86860       {
86861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86862       };
86863     } catch (Dali::DaliException e) {
86864       {
86865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86866       };
86867     } catch (...) {
86868       {
86869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86870       };
86871     }
86872   }
86873
86874
86875   //argout typemap for const std::string&
86876
86877 }
86878
86879
86880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86881   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86882
86883   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86884   {
86885     try {
86886       (arg1)->ApplyDefaultTheme();
86887     } catch (std::out_of_range& e) {
86888       {
86889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86890       };
86891     } catch (std::exception& e) {
86892       {
86893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86894       };
86895     } catch (Dali::DaliException e) {
86896       {
86897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86898       };
86899     } catch (...) {
86900       {
86901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86902       };
86903     }
86904   }
86905
86906 }
86907
86908
86909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86910   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86911   std::string *arg2 = 0 ;
86912   Dali::Property::Value *arg3 = 0 ;
86913
86914   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86915   if (!jarg2) {
86916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86917     return ;
86918   }
86919   std::string arg2_str(jarg2);
86920   arg2 = &arg2_str;
86921   arg3 = (Dali::Property::Value *)jarg3;
86922   if (!arg3) {
86923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86924     return ;
86925   }
86926   {
86927     try {
86928       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86929     } catch (std::out_of_range& e) {
86930       {
86931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86932       };
86933     } catch (std::exception& e) {
86934       {
86935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86936       };
86937     } catch (Dali::DaliException e) {
86938       {
86939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86940       };
86941     } catch (...) {
86942       {
86943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86944       };
86945     }
86946   }
86947
86948
86949   //argout typemap for const std::string&
86950
86951 }
86952
86953
86954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86955   unsigned int jresult ;
86956   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86957   std::string *arg2 = 0 ;
86958   Dali::Property::Value *arg3 = 0 ;
86959   bool result;
86960
86961   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86962   if (!jarg2) {
86963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86964     return 0;
86965   }
86966   std::string arg2_str(jarg2);
86967   arg2 = &arg2_str;
86968   arg3 = (Dali::Property::Value *)jarg3;
86969   if (!arg3) {
86970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86971     return 0;
86972   }
86973   {
86974     try {
86975       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86976     } catch (std::out_of_range& e) {
86977       {
86978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86979       };
86980     } catch (std::exception& e) {
86981       {
86982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86983       };
86984     } catch (Dali::DaliException e) {
86985       {
86986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86987       };
86988     } catch (...) {
86989       {
86990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86991       };
86992     }
86993   }
86994
86995   jresult = result;
86996
86997   //argout typemap for const std::string&
86998
86999   return jresult;
87000 }
87001
87002
87003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
87004   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87005   Dali::Toolkit::Control arg2 ;
87006   std::string *arg3 = 0 ;
87007   std::string *arg4 = 0 ;
87008   Dali::Toolkit::Control *argp2 ;
87009
87010   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87011   argp2 = (Dali::Toolkit::Control *)jarg2;
87012   if (!argp2) {
87013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87014     return ;
87015   }
87016   arg2 = *argp2;
87017   if (!jarg3) {
87018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87019     return ;
87020   }
87021   std::string arg3_str(jarg3);
87022   arg3 = &arg3_str;
87023   if (!jarg4) {
87024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87025     return ;
87026   }
87027   std::string arg4_str(jarg4);
87028   arg4 = &arg4_str;
87029   {
87030     try {
87031       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87032     } catch (std::out_of_range& e) {
87033       {
87034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87035       };
87036     } catch (std::exception& e) {
87037       {
87038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87039       };
87040     } catch (Dali::DaliException e) {
87041       {
87042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87043       };
87044     } catch (...) {
87045       {
87046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87047       };
87048     }
87049   }
87050
87051
87052   //argout typemap for const std::string&
87053
87054
87055   //argout typemap for const std::string&
87056
87057 }
87058
87059
87060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87061   void * jresult ;
87062   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87063   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87064
87065   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87066   {
87067     try {
87068       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87069     } catch (std::out_of_range& e) {
87070       {
87071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87072       };
87073     } catch (std::exception& e) {
87074       {
87075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87076       };
87077     } catch (Dali::DaliException e) {
87078       {
87079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87080       };
87081     } catch (...) {
87082       {
87083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87084       };
87085     }
87086   }
87087
87088   jresult = (void *)result;
87089   return jresult;
87090 }
87091
87092
87093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87094   int jresult ;
87095   int result;
87096
87097   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87098   jresult = (int)result;
87099   return jresult;
87100 }
87101
87102
87103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87104   int jresult ;
87105   int result;
87106
87107   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87108   jresult = (int)result;
87109   return jresult;
87110 }
87111
87112
87113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87114   int jresult ;
87115   int result;
87116
87117   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87118   jresult = (int)result;
87119   return jresult;
87120 }
87121
87122
87123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87124   int jresult ;
87125   int result;
87126
87127   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87128   jresult = (int)result;
87129   return jresult;
87130 }
87131
87132
87133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87134   int jresult ;
87135   int result;
87136
87137   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87138   jresult = (int)result;
87139   return jresult;
87140 }
87141
87142
87143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87144   int jresult ;
87145   int result;
87146
87147   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87148   jresult = (int)result;
87149   return jresult;
87150 }
87151
87152
87153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87154   int jresult ;
87155   int result;
87156
87157   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87158   jresult = (int)result;
87159   return jresult;
87160 }
87161
87162
87163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87164   int jresult ;
87165   int result;
87166
87167   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87168   jresult = (int)result;
87169   return jresult;
87170 }
87171
87172
87173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87174   int jresult ;
87175   int result;
87176
87177   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87178   jresult = (int)result;
87179   return jresult;
87180 }
87181
87182
87183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87184   int jresult ;
87185   int result;
87186
87187   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87188   jresult = (int)result;
87189   return jresult;
87190 }
87191
87192
87193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87194   int jresult ;
87195   int result;
87196
87197   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87198   jresult = (int)result;
87199   return jresult;
87200 }
87201
87202
87203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87204   int jresult ;
87205   int result;
87206
87207   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87208   jresult = (int)result;
87209   return jresult;
87210 }
87211
87212
87213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87214   int jresult ;
87215   int result;
87216
87217   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87218   jresult = (int)result;
87219   return jresult;
87220 }
87221
87222
87223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87224   int jresult ;
87225   int result;
87226
87227   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87228   jresult = (int)result;
87229   return jresult;
87230 }
87231
87232
87233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87234   int jresult ;
87235   int result;
87236
87237   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87238   jresult = (int)result;
87239   return jresult;
87240 }
87241
87242
87243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87244   void * jresult ;
87245   Dali::Toolkit::Slider::Property *result = 0 ;
87246
87247   {
87248     try {
87249       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87250     } catch (std::out_of_range& e) {
87251       {
87252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87253       };
87254     } catch (std::exception& e) {
87255       {
87256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87257       };
87258     } catch (Dali::DaliException e) {
87259       {
87260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87261       };
87262     } catch (...) {
87263       {
87264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87265       };
87266     }
87267   }
87268
87269   jresult = (void *)result;
87270   return jresult;
87271 }
87272
87273
87274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87275   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87276
87277   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87278   {
87279     try {
87280       delete arg1;
87281     } catch (std::out_of_range& e) {
87282       {
87283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87284       };
87285     } catch (std::exception& e) {
87286       {
87287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87288       };
87289     } catch (Dali::DaliException e) {
87290       {
87291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87292       };
87293     } catch (...) {
87294       {
87295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87296       };
87297     }
87298   }
87299
87300 }
87301
87302
87303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87304   void * jresult ;
87305   Dali::Toolkit::Slider result;
87306
87307   {
87308     try {
87309       result = Dali::Toolkit::Slider::New();
87310     } catch (std::out_of_range& e) {
87311       {
87312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87313       };
87314     } catch (std::exception& e) {
87315       {
87316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87317       };
87318     } catch (Dali::DaliException e) {
87319       {
87320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87321       };
87322     } catch (...) {
87323       {
87324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87325       };
87326     }
87327   }
87328
87329   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87330   return jresult;
87331 }
87332
87333
87334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87335   void * jresult ;
87336   Dali::Toolkit::Slider *result = 0 ;
87337
87338   {
87339     try {
87340       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87341     } catch (std::out_of_range& e) {
87342       {
87343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87344       };
87345     } catch (std::exception& e) {
87346       {
87347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87348       };
87349     } catch (Dali::DaliException e) {
87350       {
87351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87352       };
87353     } catch (...) {
87354       {
87355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87356       };
87357     }
87358   }
87359
87360   jresult = (void *)result;
87361   return jresult;
87362 }
87363
87364
87365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87366   void * jresult ;
87367   Dali::Toolkit::Slider *arg1 = 0 ;
87368   Dali::Toolkit::Slider *result = 0 ;
87369
87370   arg1 = (Dali::Toolkit::Slider *)jarg1;
87371   if (!arg1) {
87372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87373     return 0;
87374   }
87375   {
87376     try {
87377       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87378     } catch (std::out_of_range& e) {
87379       {
87380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87381       };
87382     } catch (std::exception& e) {
87383       {
87384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87385       };
87386     } catch (Dali::DaliException e) {
87387       {
87388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87389       };
87390     } catch (...) {
87391       {
87392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87393       };
87394     }
87395   }
87396
87397   jresult = (void *)result;
87398   return jresult;
87399 }
87400
87401
87402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87403   void * jresult ;
87404   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87405   Dali::Toolkit::Slider *arg2 = 0 ;
87406   Dali::Toolkit::Slider *result = 0 ;
87407
87408   arg1 = (Dali::Toolkit::Slider *)jarg1;
87409   arg2 = (Dali::Toolkit::Slider *)jarg2;
87410   if (!arg2) {
87411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87412     return 0;
87413   }
87414   {
87415     try {
87416       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87417     } catch (std::out_of_range& e) {
87418       {
87419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87420       };
87421     } catch (std::exception& e) {
87422       {
87423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87424       };
87425     } catch (Dali::DaliException e) {
87426       {
87427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87428       };
87429     } catch (...) {
87430       {
87431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87432       };
87433     }
87434   }
87435
87436   jresult = (void *)result;
87437   return jresult;
87438 }
87439
87440
87441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87442   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87443
87444   arg1 = (Dali::Toolkit::Slider *)jarg1;
87445   {
87446     try {
87447       delete arg1;
87448     } catch (std::out_of_range& e) {
87449       {
87450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87451       };
87452     } catch (std::exception& e) {
87453       {
87454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87455       };
87456     } catch (Dali::DaliException e) {
87457       {
87458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87459       };
87460     } catch (...) {
87461       {
87462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87463       };
87464     }
87465   }
87466
87467 }
87468
87469
87470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87471   void * jresult ;
87472   Dali::BaseHandle arg1 ;
87473   Dali::BaseHandle *argp1 ;
87474   Dali::Toolkit::Slider result;
87475
87476   argp1 = (Dali::BaseHandle *)jarg1;
87477   if (!argp1) {
87478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87479     return 0;
87480   }
87481   arg1 = *argp1;
87482   {
87483     try {
87484       result = Dali::Toolkit::Slider::DownCast(arg1);
87485     } catch (std::out_of_range& e) {
87486       {
87487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87488       };
87489     } catch (std::exception& e) {
87490       {
87491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87492       };
87493     } catch (Dali::DaliException e) {
87494       {
87495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87496       };
87497     } catch (...) {
87498       {
87499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87500       };
87501     }
87502   }
87503
87504   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87505   return jresult;
87506 }
87507
87508
87509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87510   void * jresult ;
87511   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87512   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87513
87514   arg1 = (Dali::Toolkit::Slider *)jarg1;
87515   {
87516     try {
87517       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87518     } catch (std::out_of_range& e) {
87519       {
87520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87521       };
87522     } catch (std::exception& e) {
87523       {
87524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87525       };
87526     } catch (Dali::DaliException e) {
87527       {
87528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87529       };
87530     } catch (...) {
87531       {
87532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87533       };
87534     }
87535   }
87536
87537   jresult = (void *)result;
87538   return jresult;
87539 }
87540
87541
87542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87543   void * jresult ;
87544   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87545   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87546
87547   arg1 = (Dali::Toolkit::Slider *)jarg1;
87548   {
87549     try {
87550       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87551     } catch (std::out_of_range& e) {
87552       {
87553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87554       };
87555     } catch (std::exception& e) {
87556       {
87557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87558       };
87559     } catch (Dali::DaliException e) {
87560       {
87561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87562       };
87563     } catch (...) {
87564       {
87565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87566       };
87567     }
87568   }
87569
87570   jresult = (void *)result;
87571   return jresult;
87572 }
87573
87574
87575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87576   void * jresult ;
87577   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87578   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87579
87580   arg1 = (Dali::Toolkit::Slider *)jarg1;
87581   {
87582     try {
87583       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87584     } catch (std::out_of_range& e) {
87585       {
87586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87587       };
87588     } catch (std::exception& e) {
87589       {
87590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87591       };
87592     } catch (Dali::DaliException e) {
87593       {
87594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87595       };
87596     } catch (...) {
87597       {
87598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87599       };
87600     }
87601   }
87602
87603   jresult = (void *)result;
87604   return jresult;
87605 }
87606
87607
87608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87609   int jresult ;
87610   int result;
87611
87612   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87613   jresult = (int)result;
87614   return jresult;
87615 }
87616
87617
87618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87619   int jresult ;
87620   int result;
87621
87622   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87623   jresult = (int)result;
87624   return jresult;
87625 }
87626
87627
87628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87629   int jresult ;
87630   int result;
87631
87632   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87633   jresult = (int)result;
87634   return jresult;
87635 }
87636
87637
87638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87639   int jresult ;
87640   int result;
87641
87642   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87643   jresult = (int)result;
87644   return jresult;
87645 }
87646
87647
87648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87649   int result;
87650
87651   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87652
87653   return result;
87654 }
87655
87656
87657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87658   void * jresult ;
87659   Dali::Toolkit::VideoView::Property *result = 0 ;
87660
87661   {
87662     try {
87663       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87664     } catch (std::out_of_range& e) {
87665       {
87666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87667       };
87668     } catch (std::exception& e) {
87669       {
87670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87671       };
87672     } catch (Dali::DaliException e) {
87673       {
87674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87675       };
87676     } catch (...) {
87677       {
87678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87679       };
87680     }
87681   }
87682
87683   jresult = (void *)result;
87684   return jresult;
87685 }
87686
87687
87688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87689   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87690
87691   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87692   {
87693     try {
87694       delete arg1;
87695     } catch (std::out_of_range& e) {
87696       {
87697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87698       };
87699     } catch (std::exception& e) {
87700       {
87701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87702       };
87703     } catch (Dali::DaliException e) {
87704       {
87705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87706       };
87707     } catch (...) {
87708       {
87709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87710       };
87711     }
87712   }
87713
87714 }
87715
87716
87717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87718   void * jresult ;
87719   Dali::Toolkit::VideoView result;
87720
87721   {
87722     try {
87723       result = Dali::Toolkit::VideoView::New();
87724     } catch (std::out_of_range& e) {
87725       {
87726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87727       };
87728     } catch (std::exception& e) {
87729       {
87730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87731       };
87732     } catch (Dali::DaliException e) {
87733       {
87734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87735       };
87736     } catch (...) {
87737       {
87738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87739       };
87740     }
87741   }
87742
87743   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87744   return jresult;
87745 }
87746
87747
87748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87749   void * jresult ;
87750   std::string *arg1 = 0 ;
87751   Dali::Toolkit::VideoView result;
87752
87753   if (!jarg1) {
87754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87755     return 0;
87756   }
87757   std::string arg1_str(jarg1);
87758   arg1 = &arg1_str;
87759   {
87760     try {
87761       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87762     } catch (std::out_of_range& e) {
87763       {
87764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87765       };
87766     } catch (std::exception& e) {
87767       {
87768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87769       };
87770     } catch (Dali::DaliException e) {
87771       {
87772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87773       };
87774     } catch (...) {
87775       {
87776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87777       };
87778     }
87779   }
87780
87781   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87782
87783   //argout typemap for const std::string&
87784
87785   return jresult;
87786 }
87787
87788
87789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87790   void * jresult ;
87791   Dali::Toolkit::VideoView *result = 0 ;
87792
87793   {
87794     try {
87795       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87796     } catch (std::out_of_range& e) {
87797       {
87798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87799       };
87800     } catch (std::exception& e) {
87801       {
87802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87803       };
87804     } catch (Dali::DaliException e) {
87805       {
87806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87807       };
87808     } catch (...) {
87809       {
87810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87811       };
87812     }
87813   }
87814
87815   jresult = (void *)result;
87816   return jresult;
87817 }
87818
87819
87820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87821   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87822
87823   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87824   {
87825     try {
87826       delete arg1;
87827     } catch (std::out_of_range& e) {
87828       {
87829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87830       };
87831     } catch (std::exception& e) {
87832       {
87833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87834       };
87835     } catch (Dali::DaliException e) {
87836       {
87837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87838       };
87839     } catch (...) {
87840       {
87841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87842       };
87843     }
87844   }
87845
87846 }
87847
87848
87849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87850   void * jresult ;
87851   Dali::Toolkit::VideoView *arg1 = 0 ;
87852   Dali::Toolkit::VideoView *result = 0 ;
87853
87854   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87855   if (!arg1) {
87856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87857     return 0;
87858   }
87859   {
87860     try {
87861       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87862     } catch (std::out_of_range& e) {
87863       {
87864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87865       };
87866     } catch (std::exception& e) {
87867       {
87868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87869       };
87870     } catch (Dali::DaliException e) {
87871       {
87872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87873       };
87874     } catch (...) {
87875       {
87876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87877       };
87878     }
87879   }
87880
87881   jresult = (void *)result;
87882   return jresult;
87883 }
87884
87885
87886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87887   void * jresult ;
87888   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87889   Dali::Toolkit::VideoView *arg2 = 0 ;
87890   Dali::Toolkit::VideoView *result = 0 ;
87891
87892   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87893   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87894   if (!arg2) {
87895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87896     return 0;
87897   }
87898   {
87899     try {
87900       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87901     } catch (std::out_of_range& e) {
87902       {
87903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87904       };
87905     } catch (std::exception& e) {
87906       {
87907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87908       };
87909     } catch (Dali::DaliException e) {
87910       {
87911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87912       };
87913     } catch (...) {
87914       {
87915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87916       };
87917     }
87918   }
87919
87920   jresult = (void *)result;
87921   return jresult;
87922 }
87923
87924
87925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87926   void * jresult ;
87927   Dali::BaseHandle arg1 ;
87928   Dali::BaseHandle *argp1 ;
87929   Dali::Toolkit::VideoView result;
87930
87931   argp1 = (Dali::BaseHandle *)jarg1;
87932   if (!argp1) {
87933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87934     return 0;
87935   }
87936   arg1 = *argp1;
87937   {
87938     try {
87939       result = Dali::Toolkit::VideoView::DownCast(arg1);
87940     } catch (std::out_of_range& e) {
87941       {
87942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87943       };
87944     } catch (std::exception& e) {
87945       {
87946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87947       };
87948     } catch (Dali::DaliException e) {
87949       {
87950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87951       };
87952     } catch (...) {
87953       {
87954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87955       };
87956     }
87957   }
87958
87959   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87960   return jresult;
87961 }
87962
87963
87964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87965   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87966
87967   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87968   {
87969     try {
87970       (arg1)->Play();
87971     } catch (std::out_of_range& e) {
87972       {
87973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87974       };
87975     } catch (std::exception& e) {
87976       {
87977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87978       };
87979     } catch (Dali::DaliException e) {
87980       {
87981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87982       };
87983     } catch (...) {
87984       {
87985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87986       };
87987     }
87988   }
87989
87990 }
87991
87992
87993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87994   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87995
87996   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87997   {
87998     try {
87999       (arg1)->Pause();
88000     } catch (std::out_of_range& e) {
88001       {
88002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88003       };
88004     } catch (std::exception& e) {
88005       {
88006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88007       };
88008     } catch (Dali::DaliException e) {
88009       {
88010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88011       };
88012     } catch (...) {
88013       {
88014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88015       };
88016     }
88017   }
88018
88019 }
88020
88021
88022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
88023   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88024
88025   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88026   {
88027     try {
88028       (arg1)->Stop();
88029     } catch (std::out_of_range& e) {
88030       {
88031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88032       };
88033     } catch (std::exception& e) {
88034       {
88035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88036       };
88037     } catch (Dali::DaliException e) {
88038       {
88039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88040       };
88041     } catch (...) {
88042       {
88043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88044       };
88045     }
88046   }
88047
88048 }
88049
88050
88051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88052   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88053   int arg2 ;
88054
88055   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88056   arg2 = (int)jarg2;
88057   {
88058     try {
88059       (arg1)->Forward(arg2);
88060     } catch (std::out_of_range& e) {
88061       {
88062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88063       };
88064     } catch (std::exception& e) {
88065       {
88066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88067       };
88068     } catch (Dali::DaliException e) {
88069       {
88070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88071       };
88072     } catch (...) {
88073       {
88074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88075       };
88076     }
88077   }
88078
88079 }
88080
88081
88082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88083   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88084   int arg2 ;
88085
88086   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88087   arg2 = (int)jarg2;
88088   {
88089     try {
88090       (arg1)->Backward(arg2);
88091     } catch (std::out_of_range& e) {
88092       {
88093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88094       };
88095     } catch (std::exception& e) {
88096       {
88097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88098       };
88099     } catch (Dali::DaliException e) {
88100       {
88101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88102       };
88103     } catch (...) {
88104       {
88105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88106       };
88107     }
88108   }
88109
88110 }
88111
88112
88113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88114   void * jresult ;
88115   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88116   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88117
88118   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88119   {
88120     try {
88121       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88122     } catch (std::out_of_range& e) {
88123       {
88124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88125       };
88126     } catch (std::exception& e) {
88127       {
88128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88129       };
88130     } catch (Dali::DaliException e) {
88131       {
88132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88133       };
88134     } catch (...) {
88135       {
88136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88137       };
88138     }
88139   }
88140
88141   jresult = (void *)result;
88142   return jresult;
88143 }
88144
88145
88146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88147   int jresult ;
88148   int result;
88149
88150   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88151   jresult = (int)result;
88152   return jresult;
88153 }
88154
88155
88156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88157   int jresult ;
88158   int result;
88159
88160   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88161   jresult = (int)result;
88162   return jresult;
88163 }
88164
88165
88166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88167   int jresult ;
88168   int result;
88169
88170   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88171   jresult = (int)result;
88172   return jresult;
88173 }
88174
88175
88176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88177   int jresult ;
88178   int result;
88179
88180   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88181   jresult = (int)result;
88182   return jresult;
88183 }
88184
88185
88186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88187   int jresult ;
88188   int result;
88189
88190   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88191   jresult = (int)result;
88192   return jresult;
88193 }
88194
88195
88196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88197   int jresult ;
88198   int result;
88199
88200   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88201   jresult = (int)result;
88202   return jresult;
88203 }
88204
88205
88206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88207   int jresult ;
88208   int result;
88209
88210   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88211   jresult = (int)result;
88212   return jresult;
88213 }
88214
88215
88216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88217   int jresult ;
88218   int result;
88219
88220   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88221   jresult = (int)result;
88222   return jresult;
88223 }
88224
88225
88226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88227   int jresult ;
88228   int result;
88229
88230   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88231   jresult = (int)result;
88232   return jresult;
88233 }
88234
88235
88236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88237   int jresult ;
88238   int result;
88239
88240   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88241   jresult = (int)result;
88242   return jresult;
88243 }
88244
88245
88246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88247   int jresult ;
88248   int result;
88249
88250   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88251   jresult = (int)result;
88252   return jresult;
88253 }
88254
88255
88256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88257   int jresult ;
88258   int result;
88259
88260   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88261   jresult = (int)result;
88262   return jresult;
88263 }
88264
88265
88266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88267   int jresult ;
88268   int result;
88269
88270   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88271   jresult = (int)result;
88272   return jresult;
88273 }
88274
88275
88276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88277   int jresult ;
88278   int result;
88279
88280   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88281   jresult = (int)result;
88282   return jresult;
88283 }
88284
88285
88286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88287   int jresult ;
88288   int result;
88289
88290   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88291   jresult = (int)result;
88292   return jresult;
88293 }
88294
88295
88296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88297   int jresult ;
88298   int result;
88299
88300   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88301   jresult = (int)result;
88302   return jresult;
88303 }
88304
88305
88306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88307   int jresult ;
88308   int result;
88309
88310   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88311   jresult = (int)result;
88312   return jresult;
88313 }
88314
88315
88316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88317   int jresult ;
88318   int result;
88319
88320   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88321   jresult = (int)result;
88322   return jresult;
88323 }
88324
88325
88326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88327   int jresult ;
88328   int result;
88329
88330   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88331   jresult = (int)result;
88332   return jresult;
88333 }
88334
88335
88336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88337   int jresult ;
88338   int result;
88339
88340   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88341   jresult = (int)result;
88342   return jresult;
88343 }
88344
88345
88346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88347   int jresult ;
88348   int result;
88349
88350   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88351   jresult = (int)result;
88352   return jresult;
88353 }
88354
88355
88356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88357   void * jresult ;
88358   Dali::Toolkit::Popup::Property *result = 0 ;
88359
88360   {
88361     try {
88362       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88363     } catch (std::out_of_range& e) {
88364       {
88365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88366       };
88367     } catch (std::exception& e) {
88368       {
88369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88370       };
88371     } catch (Dali::DaliException e) {
88372       {
88373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88374       };
88375     } catch (...) {
88376       {
88377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88378       };
88379     }
88380   }
88381
88382   jresult = (void *)result;
88383   return jresult;
88384 }
88385
88386
88387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88388   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88389
88390   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88391   {
88392     try {
88393       delete arg1;
88394     } catch (std::out_of_range& e) {
88395       {
88396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88397       };
88398     } catch (std::exception& e) {
88399       {
88400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88401       };
88402     } catch (Dali::DaliException e) {
88403       {
88404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88405       };
88406     } catch (...) {
88407       {
88408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88409       };
88410     }
88411   }
88412
88413 }
88414
88415
88416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88417   void * jresult ;
88418   Dali::Toolkit::Popup *result = 0 ;
88419
88420   {
88421     try {
88422       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88423     } catch (std::out_of_range& e) {
88424       {
88425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88426       };
88427     } catch (std::exception& e) {
88428       {
88429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88430       };
88431     } catch (Dali::DaliException e) {
88432       {
88433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88434       };
88435     } catch (...) {
88436       {
88437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88438       };
88439     }
88440   }
88441
88442   jresult = (void *)result;
88443   return jresult;
88444 }
88445
88446
88447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88448   void * jresult ;
88449   Dali::Toolkit::Popup result;
88450
88451   {
88452     try {
88453       result = Dali::Toolkit::Popup::New();
88454     } catch (std::out_of_range& e) {
88455       {
88456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88457       };
88458     } catch (std::exception& e) {
88459       {
88460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88461       };
88462     } catch (Dali::DaliException e) {
88463       {
88464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88465       };
88466     } catch (...) {
88467       {
88468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88469       };
88470     }
88471   }
88472
88473   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88474   return jresult;
88475 }
88476
88477
88478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88479   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88480
88481   arg1 = (Dali::Toolkit::Popup *)jarg1;
88482   {
88483     try {
88484       delete arg1;
88485     } catch (std::out_of_range& e) {
88486       {
88487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88488       };
88489     } catch (std::exception& e) {
88490       {
88491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88492       };
88493     } catch (Dali::DaliException e) {
88494       {
88495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88496       };
88497     } catch (...) {
88498       {
88499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88500       };
88501     }
88502   }
88503
88504 }
88505
88506
88507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88508   void * jresult ;
88509   Dali::Toolkit::Popup *arg1 = 0 ;
88510   Dali::Toolkit::Popup *result = 0 ;
88511
88512   arg1 = (Dali::Toolkit::Popup *)jarg1;
88513   if (!arg1) {
88514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88515     return 0;
88516   }
88517   {
88518     try {
88519       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88520     } catch (std::out_of_range& e) {
88521       {
88522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88523       };
88524     } catch (std::exception& e) {
88525       {
88526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88527       };
88528     } catch (Dali::DaliException e) {
88529       {
88530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88531       };
88532     } catch (...) {
88533       {
88534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88535       };
88536     }
88537   }
88538
88539   jresult = (void *)result;
88540   return jresult;
88541 }
88542
88543
88544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88545   void * jresult ;
88546   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88547   Dali::Toolkit::Popup *arg2 = 0 ;
88548   Dali::Toolkit::Popup *result = 0 ;
88549
88550   arg1 = (Dali::Toolkit::Popup *)jarg1;
88551   arg2 = (Dali::Toolkit::Popup *)jarg2;
88552   if (!arg2) {
88553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88554     return 0;
88555   }
88556   {
88557     try {
88558       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88559     } catch (std::out_of_range& e) {
88560       {
88561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88562       };
88563     } catch (std::exception& e) {
88564       {
88565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88566       };
88567     } catch (Dali::DaliException e) {
88568       {
88569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88570       };
88571     } catch (...) {
88572       {
88573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88574       };
88575     }
88576   }
88577
88578   jresult = (void *)result;
88579   return jresult;
88580 }
88581
88582
88583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88584   void * jresult ;
88585   Dali::BaseHandle arg1 ;
88586   Dali::BaseHandle *argp1 ;
88587   Dali::Toolkit::Popup result;
88588
88589   argp1 = (Dali::BaseHandle *)jarg1;
88590   if (!argp1) {
88591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88592     return 0;
88593   }
88594   arg1 = *argp1;
88595   {
88596     try {
88597       result = Dali::Toolkit::Popup::DownCast(arg1);
88598     } catch (std::out_of_range& e) {
88599       {
88600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88601       };
88602     } catch (std::exception& e) {
88603       {
88604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88605       };
88606     } catch (Dali::DaliException e) {
88607       {
88608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88609       };
88610     } catch (...) {
88611       {
88612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88613       };
88614     }
88615   }
88616
88617   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88618   return jresult;
88619 }
88620
88621
88622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88623   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88624   Dali::Actor arg2 ;
88625   Dali::Actor *argp2 ;
88626
88627   arg1 = (Dali::Toolkit::Popup *)jarg1;
88628   argp2 = (Dali::Actor *)jarg2;
88629   if (!argp2) {
88630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88631     return ;
88632   }
88633   arg2 = *argp2;
88634   {
88635     try {
88636       (arg1)->SetTitle(arg2);
88637     } catch (std::out_of_range& e) {
88638       {
88639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88640       };
88641     } catch (std::exception& e) {
88642       {
88643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88644       };
88645     } catch (Dali::DaliException e) {
88646       {
88647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88648       };
88649     } catch (...) {
88650       {
88651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88652       };
88653     }
88654   }
88655
88656 }
88657
88658
88659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88660   void * jresult ;
88661   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88662   Dali::Actor result;
88663
88664   arg1 = (Dali::Toolkit::Popup *)jarg1;
88665   {
88666     try {
88667       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88668     } catch (std::out_of_range& e) {
88669       {
88670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88671       };
88672     } catch (std::exception& e) {
88673       {
88674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88675       };
88676     } catch (Dali::DaliException e) {
88677       {
88678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88679       };
88680     } catch (...) {
88681       {
88682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88683       };
88684     }
88685   }
88686
88687   jresult = new Dali::Actor((const Dali::Actor &)result);
88688   return jresult;
88689 }
88690
88691
88692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88693   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88694   Dali::Actor arg2 ;
88695   Dali::Actor *argp2 ;
88696
88697   arg1 = (Dali::Toolkit::Popup *)jarg1;
88698   argp2 = (Dali::Actor *)jarg2;
88699   if (!argp2) {
88700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88701     return ;
88702   }
88703   arg2 = *argp2;
88704   {
88705     try {
88706       (arg1)->SetContent(arg2);
88707     } catch (std::out_of_range& e) {
88708       {
88709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88710       };
88711     } catch (std::exception& e) {
88712       {
88713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88714       };
88715     } catch (Dali::DaliException e) {
88716       {
88717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88718       };
88719     } catch (...) {
88720       {
88721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88722       };
88723     }
88724   }
88725
88726 }
88727
88728
88729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88730   void * jresult ;
88731   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88732   Dali::Actor result;
88733
88734   arg1 = (Dali::Toolkit::Popup *)jarg1;
88735   {
88736     try {
88737       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88738     } catch (std::out_of_range& e) {
88739       {
88740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88741       };
88742     } catch (std::exception& e) {
88743       {
88744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88745       };
88746     } catch (Dali::DaliException e) {
88747       {
88748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88749       };
88750     } catch (...) {
88751       {
88752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88753       };
88754     }
88755   }
88756
88757   jresult = new Dali::Actor((const Dali::Actor &)result);
88758   return jresult;
88759 }
88760
88761
88762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88763   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88764   Dali::Actor arg2 ;
88765   Dali::Actor *argp2 ;
88766
88767   arg1 = (Dali::Toolkit::Popup *)jarg1;
88768   argp2 = (Dali::Actor *)jarg2;
88769   if (!argp2) {
88770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88771     return ;
88772   }
88773   arg2 = *argp2;
88774   {
88775     try {
88776       (arg1)->SetFooter(arg2);
88777     } catch (std::out_of_range& e) {
88778       {
88779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88780       };
88781     } catch (std::exception& e) {
88782       {
88783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88784       };
88785     } catch (Dali::DaliException e) {
88786       {
88787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88788       };
88789     } catch (...) {
88790       {
88791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88792       };
88793     }
88794   }
88795
88796 }
88797
88798
88799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88800   void * jresult ;
88801   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88802   Dali::Actor result;
88803
88804   arg1 = (Dali::Toolkit::Popup *)jarg1;
88805   {
88806     try {
88807       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88808     } catch (std::out_of_range& e) {
88809       {
88810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88811       };
88812     } catch (std::exception& e) {
88813       {
88814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88815       };
88816     } catch (Dali::DaliException e) {
88817       {
88818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88819       };
88820     } catch (...) {
88821       {
88822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88823       };
88824     }
88825   }
88826
88827   jresult = new Dali::Actor((const Dali::Actor &)result);
88828   return jresult;
88829 }
88830
88831
88832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88833   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88834   Dali::Toolkit::Popup::DisplayState arg2 ;
88835
88836   arg1 = (Dali::Toolkit::Popup *)jarg1;
88837   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88838   {
88839     try {
88840       (arg1)->SetDisplayState(arg2);
88841     } catch (std::out_of_range& e) {
88842       {
88843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88844       };
88845     } catch (std::exception& e) {
88846       {
88847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88848       };
88849     } catch (Dali::DaliException e) {
88850       {
88851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88852       };
88853     } catch (...) {
88854       {
88855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88856       };
88857     }
88858   }
88859
88860 }
88861
88862
88863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88864   int jresult ;
88865   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88866   Dali::Toolkit::Popup::DisplayState result;
88867
88868   arg1 = (Dali::Toolkit::Popup *)jarg1;
88869   {
88870     try {
88871       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88872     } catch (std::out_of_range& e) {
88873       {
88874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88875       };
88876     } catch (std::exception& e) {
88877       {
88878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88879       };
88880     } catch (Dali::DaliException e) {
88881       {
88882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88883       };
88884     } catch (...) {
88885       {
88886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88887       };
88888     }
88889   }
88890
88891   jresult = (int)result;
88892   return jresult;
88893 }
88894
88895
88896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88897   void * jresult ;
88898   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88899   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88900
88901   arg1 = (Dali::Toolkit::Popup *)jarg1;
88902   {
88903     try {
88904       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88905     } catch (std::out_of_range& e) {
88906       {
88907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88908       };
88909     } catch (std::exception& e) {
88910       {
88911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88912       };
88913     } catch (Dali::DaliException e) {
88914       {
88915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88916       };
88917     } catch (...) {
88918       {
88919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88920       };
88921     }
88922   }
88923
88924   jresult = (void *)result;
88925   return jresult;
88926 }
88927
88928
88929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88930   void * jresult ;
88931   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88932   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88933
88934   arg1 = (Dali::Toolkit::Popup *)jarg1;
88935   {
88936     try {
88937       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88938     } catch (std::out_of_range& e) {
88939       {
88940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88941       };
88942     } catch (std::exception& e) {
88943       {
88944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88945       };
88946     } catch (Dali::DaliException e) {
88947       {
88948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88949       };
88950     } catch (...) {
88951       {
88952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88953       };
88954     }
88955   }
88956
88957   jresult = (void *)result;
88958   return jresult;
88959 }
88960
88961
88962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88963   void * jresult ;
88964   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88965   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88966
88967   arg1 = (Dali::Toolkit::Popup *)jarg1;
88968   {
88969     try {
88970       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88971     } catch (std::out_of_range& e) {
88972       {
88973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88974       };
88975     } catch (std::exception& e) {
88976       {
88977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88978       };
88979     } catch (Dali::DaliException e) {
88980       {
88981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88982       };
88983     } catch (...) {
88984       {
88985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88986       };
88987     }
88988   }
88989
88990   jresult = (void *)result;
88991   return jresult;
88992 }
88993
88994
88995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88996   void * jresult ;
88997   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88998   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88999
89000   arg1 = (Dali::Toolkit::Popup *)jarg1;
89001   {
89002     try {
89003       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
89004     } catch (std::out_of_range& e) {
89005       {
89006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89007       };
89008     } catch (std::exception& e) {
89009       {
89010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89011       };
89012     } catch (Dali::DaliException e) {
89013       {
89014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89015       };
89016     } catch (...) {
89017       {
89018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89019       };
89020     }
89021   }
89022
89023   jresult = (void *)result;
89024   return jresult;
89025 }
89026
89027
89028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89029   void * jresult ;
89030   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89031   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89032
89033   arg1 = (Dali::Toolkit::Popup *)jarg1;
89034   {
89035     try {
89036       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89037     } catch (std::out_of_range& e) {
89038       {
89039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89040       };
89041     } catch (std::exception& e) {
89042       {
89043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89044       };
89045     } catch (Dali::DaliException e) {
89046       {
89047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89048       };
89049     } catch (...) {
89050       {
89051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89052       };
89053     }
89054   }
89055
89056   jresult = (void *)result;
89057   return jresult;
89058 }
89059
89060
89061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89062   int jresult ;
89063   int result;
89064
89065   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89066   jresult = (int)result;
89067   return jresult;
89068 }
89069
89070
89071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89072   int jresult ;
89073   int result;
89074
89075   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89076   jresult = (int)result;
89077   return jresult;
89078 }
89079
89080
89081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89082   int jresult ;
89083   int result;
89084
89085   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89086   jresult = (int)result;
89087   return jresult;
89088 }
89089
89090
89091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89092   int jresult ;
89093   int result;
89094
89095   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89096   jresult = (int)result;
89097   return jresult;
89098 }
89099
89100
89101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89102   int jresult ;
89103   int result;
89104
89105   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89106   jresult = (int)result;
89107   return jresult;
89108 }
89109
89110
89111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89112   int jresult ;
89113   int result;
89114
89115   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89116   jresult = (int)result;
89117   return jresult;
89118 }
89119
89120
89121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89122   int jresult ;
89123   int result;
89124
89125   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89126   jresult = (int)result;
89127   return jresult;
89128 }
89129
89130
89131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89132   int jresult ;
89133   int result;
89134
89135   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89136   jresult = (int)result;
89137   return jresult;
89138 }
89139
89140
89141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89142   int jresult ;
89143   int result;
89144
89145   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89146   jresult = (int)result;
89147   return jresult;
89148 }
89149
89150
89151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89152   void * jresult ;
89153   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89154
89155   {
89156     try {
89157       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89158     } catch (std::out_of_range& e) {
89159       {
89160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89161       };
89162     } catch (std::exception& e) {
89163       {
89164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89165       };
89166     } catch (Dali::DaliException e) {
89167       {
89168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89169       };
89170     } catch (...) {
89171       {
89172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89173       };
89174     }
89175   }
89176
89177   jresult = (void *)result;
89178   return jresult;
89179 }
89180
89181
89182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89183   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89184
89185   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89186   {
89187     try {
89188       delete arg1;
89189     } catch (std::out_of_range& e) {
89190       {
89191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89192       };
89193     } catch (std::exception& e) {
89194       {
89195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89196       };
89197     } catch (Dali::DaliException e) {
89198       {
89199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89200       };
89201     } catch (...) {
89202       {
89203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89204       };
89205     }
89206   }
89207
89208 }
89209
89210
89211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89212   void * jresult ;
89213   Dali::Toolkit::ProgressBar result;
89214
89215   {
89216     try {
89217       result = Dali::Toolkit::ProgressBar::New();
89218     } catch (std::out_of_range& e) {
89219       {
89220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89221       };
89222     } catch (std::exception& e) {
89223       {
89224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89225       };
89226     } catch (Dali::DaliException e) {
89227       {
89228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89229       };
89230     } catch (...) {
89231       {
89232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89233       };
89234     }
89235   }
89236
89237   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89238   return jresult;
89239 }
89240
89241
89242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89243   void * jresult ;
89244   Dali::Toolkit::ProgressBar *result = 0 ;
89245
89246   {
89247     try {
89248       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89249     } catch (std::out_of_range& e) {
89250       {
89251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89252       };
89253     } catch (std::exception& e) {
89254       {
89255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89256       };
89257     } catch (Dali::DaliException e) {
89258       {
89259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89260       };
89261     } catch (...) {
89262       {
89263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89264       };
89265     }
89266   }
89267
89268   jresult = (void *)result;
89269   return jresult;
89270 }
89271
89272
89273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89274   void * jresult ;
89275   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89276   Dali::Toolkit::ProgressBar *result = 0 ;
89277
89278   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89279   if (!arg1) {
89280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89281     return 0;
89282   }
89283   {
89284     try {
89285       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89286     } catch (std::out_of_range& e) {
89287       {
89288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89289       };
89290     } catch (std::exception& e) {
89291       {
89292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89293       };
89294     } catch (Dali::DaliException e) {
89295       {
89296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89297       };
89298     } catch (...) {
89299       {
89300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89301       };
89302     }
89303   }
89304
89305   jresult = (void *)result;
89306   return jresult;
89307 }
89308
89309
89310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89311   void * jresult ;
89312   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89313   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89314   Dali::Toolkit::ProgressBar *result = 0 ;
89315
89316   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89317   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89318   if (!arg2) {
89319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89320     return 0;
89321   }
89322   {
89323     try {
89324       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89325     } catch (std::out_of_range& e) {
89326       {
89327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89328       };
89329     } catch (std::exception& e) {
89330       {
89331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89332       };
89333     } catch (Dali::DaliException e) {
89334       {
89335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89336       };
89337     } catch (...) {
89338       {
89339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89340       };
89341     }
89342   }
89343
89344   jresult = (void *)result;
89345   return jresult;
89346 }
89347
89348
89349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89350   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89351
89352   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89353   {
89354     try {
89355       delete arg1;
89356     } catch (std::out_of_range& e) {
89357       {
89358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89359       };
89360     } catch (std::exception& e) {
89361       {
89362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89363       };
89364     } catch (Dali::DaliException e) {
89365       {
89366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89367       };
89368     } catch (...) {
89369       {
89370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89371       };
89372     }
89373   }
89374
89375 }
89376
89377
89378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89379   void * jresult ;
89380   Dali::BaseHandle arg1 ;
89381   Dali::BaseHandle *argp1 ;
89382   Dali::Toolkit::ProgressBar result;
89383
89384   argp1 = (Dali::BaseHandle *)jarg1;
89385   if (!argp1) {
89386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89387     return 0;
89388   }
89389   arg1 = *argp1;
89390   {
89391     try {
89392       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89393     } catch (std::out_of_range& e) {
89394       {
89395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89396       };
89397     } catch (std::exception& e) {
89398       {
89399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89400       };
89401     } catch (Dali::DaliException e) {
89402       {
89403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89404       };
89405     } catch (...) {
89406       {
89407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89408       };
89409     }
89410   }
89411
89412   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89413   return jresult;
89414 }
89415
89416
89417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89418   void * jresult ;
89419   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89420   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89421
89422   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89423   {
89424     try {
89425       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89426     } catch (std::out_of_range& e) {
89427       {
89428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89429       };
89430     } catch (std::exception& e) {
89431       {
89432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89433       };
89434     } catch (Dali::DaliException e) {
89435       {
89436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89437       };
89438     } catch (...) {
89439       {
89440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89441       };
89442     }
89443   }
89444
89445   jresult = (void *)result;
89446   return jresult;
89447 }
89448
89449
89450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89451   void * jresult ;
89452   Dali::Toolkit::GaussianBlurView *result = 0 ;
89453
89454   {
89455     try {
89456       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89457     } catch (std::out_of_range& e) {
89458       {
89459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89460       };
89461     } catch (std::exception& e) {
89462       {
89463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89464       };
89465     } catch (Dali::DaliException e) {
89466       {
89467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89468       };
89469     } catch (...) {
89470       {
89471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89472       };
89473     }
89474   }
89475
89476   jresult = (void *)result;
89477   return jresult;
89478 }
89479
89480
89481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89482   void * jresult ;
89483   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89484   Dali::Toolkit::GaussianBlurView *result = 0 ;
89485
89486   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89487   if (!arg1) {
89488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89489     return 0;
89490   }
89491   {
89492     try {
89493       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89494     } catch (std::out_of_range& e) {
89495       {
89496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89497       };
89498     } catch (std::exception& e) {
89499       {
89500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89501       };
89502     } catch (Dali::DaliException e) {
89503       {
89504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89505       };
89506     } catch (...) {
89507       {
89508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89509       };
89510     }
89511   }
89512
89513   jresult = (void *)result;
89514   return jresult;
89515 }
89516
89517
89518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89519   void * jresult ;
89520   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89521   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89522   Dali::Toolkit::GaussianBlurView *result = 0 ;
89523
89524   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89525   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89526   if (!arg2) {
89527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89528     return 0;
89529   }
89530   {
89531     try {
89532       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89533     } catch (std::out_of_range& e) {
89534       {
89535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89536       };
89537     } catch (std::exception& e) {
89538       {
89539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89540       };
89541     } catch (Dali::DaliException e) {
89542       {
89543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89544       };
89545     } catch (...) {
89546       {
89547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89548       };
89549     }
89550   }
89551
89552   jresult = (void *)result;
89553   return jresult;
89554 }
89555
89556
89557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89558   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89559
89560   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89561   {
89562     try {
89563       delete arg1;
89564     } catch (std::out_of_range& e) {
89565       {
89566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89567       };
89568     } catch (std::exception& e) {
89569       {
89570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89571       };
89572     } catch (Dali::DaliException e) {
89573       {
89574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89575       };
89576     } catch (...) {
89577       {
89578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89579       };
89580     }
89581   }
89582
89583 }
89584
89585
89586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89587   void * jresult ;
89588   Dali::BaseHandle arg1 ;
89589   Dali::BaseHandle *argp1 ;
89590   Dali::Toolkit::GaussianBlurView result;
89591
89592   argp1 = (Dali::BaseHandle *)jarg1;
89593   if (!argp1) {
89594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89595     return 0;
89596   }
89597   arg1 = *argp1;
89598   {
89599     try {
89600       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89601     } catch (std::out_of_range& e) {
89602       {
89603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89604       };
89605     } catch (std::exception& e) {
89606       {
89607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89608       };
89609     } catch (Dali::DaliException e) {
89610       {
89611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89612       };
89613     } catch (...) {
89614       {
89615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89616       };
89617     }
89618   }
89619
89620   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89621   return jresult;
89622 }
89623
89624
89625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89626   void * jresult ;
89627   Dali::Toolkit::GaussianBlurView result;
89628
89629   {
89630     try {
89631       result = Dali::Toolkit::GaussianBlurView::New();
89632     } catch (std::out_of_range& e) {
89633       {
89634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89635       };
89636     } catch (std::exception& e) {
89637       {
89638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89639       };
89640     } catch (Dali::DaliException e) {
89641       {
89642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89643       };
89644     } catch (...) {
89645       {
89646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89647       };
89648     }
89649   }
89650
89651   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89652   return jresult;
89653 }
89654
89655
89656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89657   void * jresult ;
89658   unsigned int arg1 ;
89659   float arg2 ;
89660   Dali::Pixel::Format arg3 ;
89661   float arg4 ;
89662   float arg5 ;
89663   bool arg6 ;
89664   Dali::Toolkit::GaussianBlurView result;
89665
89666   arg1 = (unsigned int)jarg1;
89667   arg2 = (float)jarg2;
89668   arg3 = (Dali::Pixel::Format)jarg3;
89669   arg4 = (float)jarg4;
89670   arg5 = (float)jarg5;
89671   arg6 = jarg6 ? true : false;
89672   {
89673     try {
89674       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89675     } catch (std::out_of_range& e) {
89676       {
89677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89678       };
89679     } catch (std::exception& e) {
89680       {
89681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89682       };
89683     } catch (Dali::DaliException e) {
89684       {
89685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89686       };
89687     } catch (...) {
89688       {
89689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89690       };
89691     }
89692   }
89693
89694   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89695   return jresult;
89696 }
89697
89698
89699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89700   void * jresult ;
89701   unsigned int arg1 ;
89702   float arg2 ;
89703   Dali::Pixel::Format arg3 ;
89704   float arg4 ;
89705   float arg5 ;
89706   Dali::Toolkit::GaussianBlurView result;
89707
89708   arg1 = (unsigned int)jarg1;
89709   arg2 = (float)jarg2;
89710   arg3 = (Dali::Pixel::Format)jarg3;
89711   arg4 = (float)jarg4;
89712   arg5 = (float)jarg5;
89713   {
89714     try {
89715       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89716     } catch (std::out_of_range& e) {
89717       {
89718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89719       };
89720     } catch (std::exception& e) {
89721       {
89722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89723       };
89724     } catch (Dali::DaliException e) {
89725       {
89726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89727       };
89728     } catch (...) {
89729       {
89730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89731       };
89732     }
89733   }
89734
89735   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89736   return jresult;
89737 }
89738
89739
89740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89741   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89742   Dali::Actor arg2 ;
89743   Dali::Actor *argp2 ;
89744
89745   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89746   argp2 = (Dali::Actor *)jarg2;
89747   if (!argp2) {
89748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89749     return ;
89750   }
89751   arg2 = *argp2;
89752   {
89753     try {
89754       (arg1)->Add(arg2);
89755     } catch (std::out_of_range& e) {
89756       {
89757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89758       };
89759     } catch (std::exception& e) {
89760       {
89761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89762       };
89763     } catch (Dali::DaliException e) {
89764       {
89765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89766       };
89767     } catch (...) {
89768       {
89769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89770       };
89771     }
89772   }
89773
89774 }
89775
89776
89777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89778   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89779   Dali::Actor arg2 ;
89780   Dali::Actor *argp2 ;
89781
89782   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89783   argp2 = (Dali::Actor *)jarg2;
89784   if (!argp2) {
89785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89786     return ;
89787   }
89788   arg2 = *argp2;
89789   {
89790     try {
89791       (arg1)->Remove(arg2);
89792     } catch (std::out_of_range& e) {
89793       {
89794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89795       };
89796     } catch (std::exception& e) {
89797       {
89798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89799       };
89800     } catch (Dali::DaliException e) {
89801       {
89802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89803       };
89804     } catch (...) {
89805       {
89806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89807       };
89808     }
89809   }
89810
89811 }
89812
89813
89814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89815   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89816
89817   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89818   {
89819     try {
89820       (arg1)->Activate();
89821     } catch (std::out_of_range& e) {
89822       {
89823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89824       };
89825     } catch (std::exception& e) {
89826       {
89827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89828       };
89829     } catch (Dali::DaliException e) {
89830       {
89831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89832       };
89833     } catch (...) {
89834       {
89835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89836       };
89837     }
89838   }
89839
89840 }
89841
89842
89843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89844   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89845
89846   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89847   {
89848     try {
89849       (arg1)->ActivateOnce();
89850     } catch (std::out_of_range& e) {
89851       {
89852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89853       };
89854     } catch (std::exception& e) {
89855       {
89856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89857       };
89858     } catch (Dali::DaliException e) {
89859       {
89860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89861       };
89862     } catch (...) {
89863       {
89864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89865       };
89866     }
89867   }
89868
89869 }
89870
89871
89872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89873   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89874
89875   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89876   {
89877     try {
89878       (arg1)->Deactivate();
89879     } catch (std::out_of_range& e) {
89880       {
89881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89882       };
89883     } catch (std::exception& e) {
89884       {
89885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89886       };
89887     } catch (Dali::DaliException e) {
89888       {
89889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89890       };
89891     } catch (...) {
89892       {
89893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89894       };
89895     }
89896   }
89897
89898 }
89899
89900
89901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89902   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89903   Dali::Image arg2 ;
89904   Dali::FrameBufferImage arg3 ;
89905   Dali::Image *argp2 ;
89906   Dali::FrameBufferImage *argp3 ;
89907
89908   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89909   argp2 = (Dali::Image *)jarg2;
89910   if (!argp2) {
89911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89912     return ;
89913   }
89914   arg2 = *argp2;
89915   argp3 = (Dali::FrameBufferImage *)jarg3;
89916   if (!argp3) {
89917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89918     return ;
89919   }
89920   arg3 = *argp3;
89921   {
89922     try {
89923       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89924     } catch (std::out_of_range& e) {
89925       {
89926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89927       };
89928     } catch (std::exception& e) {
89929       {
89930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89931       };
89932     } catch (Dali::DaliException e) {
89933       {
89934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89935       };
89936     } catch (...) {
89937       {
89938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89939       };
89940     }
89941   }
89942
89943 }
89944
89945
89946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89947   int jresult ;
89948   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89949   Dali::Property::Index result;
89950
89951   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89952   {
89953     try {
89954       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89955     } catch (std::out_of_range& e) {
89956       {
89957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89958       };
89959     } catch (std::exception& e) {
89960       {
89961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89962       };
89963     } catch (Dali::DaliException e) {
89964       {
89965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89966       };
89967     } catch (...) {
89968       {
89969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89970       };
89971     }
89972   }
89973
89974   jresult = result;
89975   return jresult;
89976 }
89977
89978
89979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89980   void * jresult ;
89981   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89982   Dali::FrameBufferImage result;
89983
89984   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89985   {
89986     try {
89987       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89988     } catch (std::out_of_range& e) {
89989       {
89990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89991       };
89992     } catch (std::exception& e) {
89993       {
89994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89995       };
89996     } catch (Dali::DaliException e) {
89997       {
89998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89999       };
90000     } catch (...) {
90001       {
90002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90003       };
90004     }
90005   }
90006
90007   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
90008   return jresult;
90009 }
90010
90011
90012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
90013   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90014   Dali::Vector4 *arg2 = 0 ;
90015
90016   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90017   arg2 = (Dali::Vector4 *)jarg2;
90018   if (!arg2) {
90019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
90020     return ;
90021   }
90022   {
90023     try {
90024       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90025     } catch (std::out_of_range& e) {
90026       {
90027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90028       };
90029     } catch (std::exception& e) {
90030       {
90031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90032       };
90033     } catch (Dali::DaliException e) {
90034       {
90035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90036       };
90037     } catch (...) {
90038       {
90039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90040       };
90041     }
90042   }
90043
90044 }
90045
90046
90047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90048   void * jresult ;
90049   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90050   Dali::Vector4 result;
90051
90052   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90053   {
90054     try {
90055       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90056     } catch (std::out_of_range& e) {
90057       {
90058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90059       };
90060     } catch (std::exception& e) {
90061       {
90062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90063       };
90064     } catch (Dali::DaliException e) {
90065       {
90066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90067       };
90068     } catch (...) {
90069       {
90070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90071       };
90072     }
90073   }
90074
90075   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90076   return jresult;
90077 }
90078
90079
90080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90081   void * jresult ;
90082   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90083   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90084
90085   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90086   {
90087     try {
90088       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90089     } catch (std::out_of_range& e) {
90090       {
90091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90092       };
90093     } catch (std::exception& e) {
90094       {
90095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90096       };
90097     } catch (Dali::DaliException e) {
90098       {
90099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90100       };
90101     } catch (...) {
90102       {
90103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90104       };
90105     }
90106   }
90107
90108   jresult = (void *)result;
90109   return jresult;
90110 }
90111
90112
90113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90114   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90115
90116   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90117   {
90118     try {
90119       delete arg1;
90120     } catch (std::out_of_range& e) {
90121       {
90122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90123       };
90124     } catch (std::exception& e) {
90125       {
90126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90127       };
90128     } catch (Dali::DaliException e) {
90129       {
90130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90131       };
90132     } catch (...) {
90133       {
90134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90135       };
90136     }
90137   }
90138
90139 }
90140
90141
90142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90143   unsigned int jresult ;
90144   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90145   unsigned int result;
90146
90147   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90148   {
90149     try {
90150       result = (unsigned int)(arg1)->GetNumberOfPages();
90151     } catch (std::out_of_range& e) {
90152       {
90153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90154       };
90155     } catch (std::exception& e) {
90156       {
90157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90158       };
90159     } catch (Dali::DaliException e) {
90160       {
90161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90162       };
90163     } catch (...) {
90164       {
90165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90166       };
90167     }
90168   }
90169
90170   jresult = result;
90171   return jresult;
90172 }
90173
90174
90175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90176   void * jresult ;
90177   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90178   unsigned int arg2 ;
90179   Dali::Texture result;
90180
90181   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90182   arg2 = (unsigned int)jarg2;
90183   {
90184     try {
90185       result = (arg1)->NewPage(arg2);
90186     } catch (std::out_of_range& e) {
90187       {
90188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90189       };
90190     } catch (std::exception& e) {
90191       {
90192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90193       };
90194     } catch (Dali::DaliException e) {
90195       {
90196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90197       };
90198     } catch (...) {
90199       {
90200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90201       };
90202     }
90203   }
90204
90205   jresult = new Dali::Texture((const Dali::Texture &)result);
90206   return jresult;
90207 }
90208
90209
90210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90211   int jresult ;
90212   int result;
90213
90214   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90215   jresult = (int)result;
90216   return jresult;
90217 }
90218
90219
90220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90221   int jresult ;
90222   int result;
90223
90224   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90225   jresult = (int)result;
90226   return jresult;
90227 }
90228
90229
90230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90231   int jresult ;
90232   int result;
90233
90234   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90235   jresult = (int)result;
90236   return jresult;
90237 }
90238
90239
90240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90241   void * jresult ;
90242   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90243
90244   {
90245     try {
90246       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90247     } catch (std::out_of_range& e) {
90248       {
90249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90250       };
90251     } catch (std::exception& e) {
90252       {
90253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90254       };
90255     } catch (Dali::DaliException e) {
90256       {
90257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90258       };
90259     } catch (...) {
90260       {
90261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90262       };
90263     }
90264   }
90265
90266   jresult = (void *)result;
90267   return jresult;
90268 }
90269
90270
90271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90272   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90273
90274   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90275   {
90276     try {
90277       delete arg1;
90278     } catch (std::out_of_range& e) {
90279       {
90280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90281       };
90282     } catch (std::exception& e) {
90283       {
90284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90285       };
90286     } catch (Dali::DaliException e) {
90287       {
90288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90289       };
90290     } catch (...) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90293       };
90294     }
90295   }
90296
90297 }
90298
90299
90300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90301   void * jresult ;
90302   Dali::Toolkit::PageTurnView *result = 0 ;
90303
90304   {
90305     try {
90306       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90307     } catch (std::out_of_range& e) {
90308       {
90309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90310       };
90311     } catch (std::exception& e) {
90312       {
90313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90314       };
90315     } catch (Dali::DaliException e) {
90316       {
90317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90318       };
90319     } catch (...) {
90320       {
90321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90322       };
90323     }
90324   }
90325
90326   jresult = (void *)result;
90327   return jresult;
90328 }
90329
90330
90331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90332   void * jresult ;
90333   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90334   Dali::Toolkit::PageTurnView *result = 0 ;
90335
90336   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90337   if (!arg1) {
90338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90339     return 0;
90340   }
90341   {
90342     try {
90343       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90344     } catch (std::out_of_range& e) {
90345       {
90346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90347       };
90348     } catch (std::exception& e) {
90349       {
90350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90351       };
90352     } catch (Dali::DaliException e) {
90353       {
90354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90355       };
90356     } catch (...) {
90357       {
90358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90359       };
90360     }
90361   }
90362
90363   jresult = (void *)result;
90364   return jresult;
90365 }
90366
90367
90368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90369   void * jresult ;
90370   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90371   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90372   Dali::Toolkit::PageTurnView *result = 0 ;
90373
90374   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90375   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90376   if (!arg2) {
90377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90378     return 0;
90379   }
90380   {
90381     try {
90382       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90383     } catch (std::out_of_range& e) {
90384       {
90385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90386       };
90387     } catch (std::exception& e) {
90388       {
90389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90390       };
90391     } catch (Dali::DaliException e) {
90392       {
90393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90394       };
90395     } catch (...) {
90396       {
90397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90398       };
90399     }
90400   }
90401
90402   jresult = (void *)result;
90403   return jresult;
90404 }
90405
90406
90407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90408   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90409
90410   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90411   {
90412     try {
90413       delete arg1;
90414     } catch (std::out_of_range& e) {
90415       {
90416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90417       };
90418     } catch (std::exception& e) {
90419       {
90420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90421       };
90422     } catch (Dali::DaliException e) {
90423       {
90424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90425       };
90426     } catch (...) {
90427       {
90428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90429       };
90430     }
90431   }
90432
90433 }
90434
90435
90436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90437   void * jresult ;
90438   Dali::BaseHandle arg1 ;
90439   Dali::BaseHandle *argp1 ;
90440   Dali::Toolkit::PageTurnView result;
90441
90442   argp1 = (Dali::BaseHandle *)jarg1;
90443   if (!argp1) {
90444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90445     return 0;
90446   }
90447   arg1 = *argp1;
90448   {
90449     try {
90450       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90451     } catch (std::out_of_range& e) {
90452       {
90453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90454       };
90455     } catch (std::exception& e) {
90456       {
90457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90458       };
90459     } catch (Dali::DaliException e) {
90460       {
90461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90462       };
90463     } catch (...) {
90464       {
90465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90466       };
90467     }
90468   }
90469
90470   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90471   return jresult;
90472 }
90473
90474
90475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90476   void * jresult ;
90477   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90478   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90479
90480   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90481   {
90482     try {
90483       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90484     } catch (std::out_of_range& e) {
90485       {
90486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90487       };
90488     } catch (std::exception& e) {
90489       {
90490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90491       };
90492     } catch (Dali::DaliException e) {
90493       {
90494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90495       };
90496     } catch (...) {
90497       {
90498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90499       };
90500     }
90501   }
90502
90503   jresult = (void *)result;
90504   return jresult;
90505 }
90506
90507
90508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90509   void * jresult ;
90510   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90511   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90512
90513   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90514   {
90515     try {
90516       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90517     } catch (std::out_of_range& e) {
90518       {
90519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90520       };
90521     } catch (std::exception& e) {
90522       {
90523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90524       };
90525     } catch (Dali::DaliException e) {
90526       {
90527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90528       };
90529     } catch (...) {
90530       {
90531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90532       };
90533     }
90534   }
90535
90536   jresult = (void *)result;
90537   return jresult;
90538 }
90539
90540
90541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90542   void * jresult ;
90543   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90544   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90545
90546   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90547   {
90548     try {
90549       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90550     } catch (std::out_of_range& e) {
90551       {
90552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90553       };
90554     } catch (std::exception& e) {
90555       {
90556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90557       };
90558     } catch (Dali::DaliException e) {
90559       {
90560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90561       };
90562     } catch (...) {
90563       {
90564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90565       };
90566     }
90567   }
90568
90569   jresult = (void *)result;
90570   return jresult;
90571 }
90572
90573
90574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90575   void * jresult ;
90576   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90577   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90578
90579   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90580   {
90581     try {
90582       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90583     } catch (std::out_of_range& e) {
90584       {
90585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90586       };
90587     } catch (std::exception& e) {
90588       {
90589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90590       };
90591     } catch (Dali::DaliException e) {
90592       {
90593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90594       };
90595     } catch (...) {
90596       {
90597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90598       };
90599     }
90600   }
90601
90602   jresult = (void *)result;
90603   return jresult;
90604 }
90605
90606
90607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90608   void * jresult ;
90609   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90610
90611   {
90612     try {
90613       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90614     } catch (std::out_of_range& e) {
90615       {
90616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90617       };
90618     } catch (std::exception& e) {
90619       {
90620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90621       };
90622     } catch (Dali::DaliException e) {
90623       {
90624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90625       };
90626     } catch (...) {
90627       {
90628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90629       };
90630     }
90631   }
90632
90633   jresult = (void *)result;
90634   return jresult;
90635 }
90636
90637
90638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90639   void * jresult ;
90640   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90641   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90642
90643   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90644   if (!arg1) {
90645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90646     return 0;
90647   }
90648   {
90649     try {
90650       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90651     } catch (std::out_of_range& e) {
90652       {
90653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90654       };
90655     } catch (std::exception& e) {
90656       {
90657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90658       };
90659     } catch (Dali::DaliException e) {
90660       {
90661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90662       };
90663     } catch (...) {
90664       {
90665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90666       };
90667     }
90668   }
90669
90670   jresult = (void *)result;
90671   return jresult;
90672 }
90673
90674
90675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90676   void * jresult ;
90677   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90678   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90679   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90680
90681   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90682   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90683   if (!arg2) {
90684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90685     return 0;
90686   }
90687   {
90688     try {
90689       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90690     } catch (std::out_of_range& e) {
90691       {
90692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90693       };
90694     } catch (std::exception& e) {
90695       {
90696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90697       };
90698     } catch (Dali::DaliException e) {
90699       {
90700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90701       };
90702     } catch (...) {
90703       {
90704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90705       };
90706     }
90707   }
90708
90709   jresult = (void *)result;
90710   return jresult;
90711 }
90712
90713
90714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90715   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90716
90717   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90718   {
90719     try {
90720       delete arg1;
90721     } catch (std::out_of_range& e) {
90722       {
90723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90724       };
90725     } catch (std::exception& e) {
90726       {
90727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90728       };
90729     } catch (Dali::DaliException e) {
90730       {
90731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90732       };
90733     } catch (...) {
90734       {
90735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90736       };
90737     }
90738   }
90739
90740 }
90741
90742
90743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90744   void * jresult ;
90745   Dali::Toolkit::PageFactory *arg1 = 0 ;
90746   Dali::Vector2 *arg2 = 0 ;
90747   Dali::Toolkit::PageTurnLandscapeView result;
90748
90749   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90750   if (!arg1) {
90751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90752     return 0;
90753   }
90754   arg2 = (Dali::Vector2 *)jarg2;
90755   if (!arg2) {
90756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90757     return 0;
90758   }
90759   {
90760     try {
90761       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90762     } catch (std::out_of_range& e) {
90763       {
90764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90765       };
90766     } catch (std::exception& e) {
90767       {
90768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90769       };
90770     } catch (Dali::DaliException e) {
90771       {
90772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90773       };
90774     } catch (...) {
90775       {
90776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90777       };
90778     }
90779   }
90780
90781   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90782   return jresult;
90783 }
90784
90785
90786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90787   void * jresult ;
90788   Dali::BaseHandle arg1 ;
90789   Dali::BaseHandle *argp1 ;
90790   Dali::Toolkit::PageTurnLandscapeView result;
90791
90792   argp1 = (Dali::BaseHandle *)jarg1;
90793   if (!argp1) {
90794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90795     return 0;
90796   }
90797   arg1 = *argp1;
90798   {
90799     try {
90800       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90801     } catch (std::out_of_range& e) {
90802       {
90803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90804       };
90805     } catch (std::exception& e) {
90806       {
90807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90808       };
90809     } catch (Dali::DaliException e) {
90810       {
90811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90812       };
90813     } catch (...) {
90814       {
90815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90816       };
90817     }
90818   }
90819
90820   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90821   return jresult;
90822 }
90823
90824
90825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90826   void * jresult ;
90827   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90828
90829   {
90830     try {
90831       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90832     } catch (std::out_of_range& e) {
90833       {
90834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90835       };
90836     } catch (std::exception& e) {
90837       {
90838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90839       };
90840     } catch (Dali::DaliException e) {
90841       {
90842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90843       };
90844     } catch (...) {
90845       {
90846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90847       };
90848     }
90849   }
90850
90851   jresult = (void *)result;
90852   return jresult;
90853 }
90854
90855
90856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90857   void * jresult ;
90858   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90859   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90860
90861   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90862   if (!arg1) {
90863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90864     return 0;
90865   }
90866   {
90867     try {
90868       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90869     } catch (std::out_of_range& e) {
90870       {
90871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90872       };
90873     } catch (std::exception& e) {
90874       {
90875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90876       };
90877     } catch (Dali::DaliException e) {
90878       {
90879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90880       };
90881     } catch (...) {
90882       {
90883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90884       };
90885     }
90886   }
90887
90888   jresult = (void *)result;
90889   return jresult;
90890 }
90891
90892
90893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90894   void * jresult ;
90895   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90896   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90897   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90898
90899   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90900   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90901   if (!arg2) {
90902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90903     return 0;
90904   }
90905   {
90906     try {
90907       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90908     } catch (std::out_of_range& e) {
90909       {
90910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90911       };
90912     } catch (std::exception& e) {
90913       {
90914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90915       };
90916     } catch (Dali::DaliException e) {
90917       {
90918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90919       };
90920     } catch (...) {
90921       {
90922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90923       };
90924     }
90925   }
90926
90927   jresult = (void *)result;
90928   return jresult;
90929 }
90930
90931
90932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90933   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90934
90935   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90936   {
90937     try {
90938       delete arg1;
90939     } catch (std::out_of_range& e) {
90940       {
90941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90942       };
90943     } catch (std::exception& e) {
90944       {
90945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90946       };
90947     } catch (Dali::DaliException e) {
90948       {
90949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90950       };
90951     } catch (...) {
90952       {
90953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90954       };
90955     }
90956   }
90957
90958 }
90959
90960
90961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90962   void * jresult ;
90963   Dali::Toolkit::PageFactory *arg1 = 0 ;
90964   Dali::Vector2 *arg2 = 0 ;
90965   Dali::Toolkit::PageTurnPortraitView result;
90966
90967   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90968   if (!arg1) {
90969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90970     return 0;
90971   }
90972   arg2 = (Dali::Vector2 *)jarg2;
90973   if (!arg2) {
90974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90975     return 0;
90976   }
90977   {
90978     try {
90979       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90980     } catch (std::out_of_range& e) {
90981       {
90982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90983       };
90984     } catch (std::exception& e) {
90985       {
90986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90987       };
90988     } catch (Dali::DaliException e) {
90989       {
90990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90991       };
90992     } catch (...) {
90993       {
90994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90995       };
90996     }
90997   }
90998
90999   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91000   return jresult;
91001 }
91002
91003
91004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
91005   void * jresult ;
91006   Dali::BaseHandle arg1 ;
91007   Dali::BaseHandle *argp1 ;
91008   Dali::Toolkit::PageTurnPortraitView result;
91009
91010   argp1 = (Dali::BaseHandle *)jarg1;
91011   if (!argp1) {
91012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91013     return 0;
91014   }
91015   arg1 = *argp1;
91016   {
91017     try {
91018       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
91019     } catch (std::out_of_range& e) {
91020       {
91021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91022       };
91023     } catch (std::exception& e) {
91024       {
91025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91026       };
91027     } catch (Dali::DaliException e) {
91028       {
91029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91030       };
91031     } catch (...) {
91032       {
91033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91034       };
91035     }
91036   }
91037
91038   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91039   return jresult;
91040 }
91041
91042
91043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91044   int jresult ;
91045   int result;
91046
91047   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91048   jresult = (int)result;
91049   return jresult;
91050 }
91051
91052
91053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91054   int jresult ;
91055   int result;
91056
91057   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91058   jresult = (int)result;
91059   return jresult;
91060 }
91061
91062
91063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91064   int jresult ;
91065   int result;
91066
91067   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91068   jresult = (int)result;
91069   return jresult;
91070 }
91071
91072
91073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91074   void * jresult ;
91075   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91076
91077   {
91078     try {
91079       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91080     } catch (std::out_of_range& e) {
91081       {
91082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91083       };
91084     } catch (std::exception& e) {
91085       {
91086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91087       };
91088     } catch (Dali::DaliException e) {
91089       {
91090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91091       };
91092     } catch (...) {
91093       {
91094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91095       };
91096     }
91097   }
91098
91099   jresult = (void *)result;
91100   return jresult;
91101 }
91102
91103
91104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91105   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91106
91107   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91108   {
91109     try {
91110       delete arg1;
91111     } catch (std::out_of_range& e) {
91112       {
91113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91114       };
91115     } catch (std::exception& e) {
91116       {
91117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91118       };
91119     } catch (Dali::DaliException e) {
91120       {
91121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91122       };
91123     } catch (...) {
91124       {
91125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91126       };
91127     }
91128   }
91129
91130 }
91131
91132
91133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91134   void * jresult ;
91135   Dali::Toolkit::ToggleButton *result = 0 ;
91136
91137   {
91138     try {
91139       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91140     } catch (std::out_of_range& e) {
91141       {
91142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91143       };
91144     } catch (std::exception& e) {
91145       {
91146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91147       };
91148     } catch (Dali::DaliException e) {
91149       {
91150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91151       };
91152     } catch (...) {
91153       {
91154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91155       };
91156     }
91157   }
91158
91159   jresult = (void *)result;
91160   return jresult;
91161 }
91162
91163
91164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91165   void * jresult ;
91166   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91167   Dali::Toolkit::ToggleButton *result = 0 ;
91168
91169   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91170   if (!arg1) {
91171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91172     return 0;
91173   }
91174   {
91175     try {
91176       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91177     } catch (std::out_of_range& e) {
91178       {
91179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91180       };
91181     } catch (std::exception& e) {
91182       {
91183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91184       };
91185     } catch (Dali::DaliException e) {
91186       {
91187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91188       };
91189     } catch (...) {
91190       {
91191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91192       };
91193     }
91194   }
91195
91196   jresult = (void *)result;
91197   return jresult;
91198 }
91199
91200
91201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91202   void * jresult ;
91203   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91204   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91205   Dali::Toolkit::ToggleButton *result = 0 ;
91206
91207   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91208   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91209   if (!arg2) {
91210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91211     return 0;
91212   }
91213   {
91214     try {
91215       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91216     } catch (std::out_of_range& e) {
91217       {
91218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91219       };
91220     } catch (std::exception& e) {
91221       {
91222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91223       };
91224     } catch (Dali::DaliException e) {
91225       {
91226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91227       };
91228     } catch (...) {
91229       {
91230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91231       };
91232     }
91233   }
91234
91235   jresult = (void *)result;
91236   return jresult;
91237 }
91238
91239
91240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91241   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91242
91243   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91244   {
91245     try {
91246       delete arg1;
91247     } catch (std::out_of_range& e) {
91248       {
91249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91250       };
91251     } catch (std::exception& e) {
91252       {
91253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91254       };
91255     } catch (Dali::DaliException e) {
91256       {
91257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91258       };
91259     } catch (...) {
91260       {
91261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91262       };
91263     }
91264   }
91265
91266 }
91267
91268
91269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91270   void * jresult ;
91271   Dali::Toolkit::ToggleButton result;
91272
91273   {
91274     try {
91275       result = Dali::Toolkit::ToggleButton::New();
91276     } catch (std::out_of_range& e) {
91277       {
91278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91279       };
91280     } catch (std::exception& e) {
91281       {
91282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91283       };
91284     } catch (Dali::DaliException e) {
91285       {
91286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91287       };
91288     } catch (...) {
91289       {
91290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91291       };
91292     }
91293   }
91294
91295   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91296   return jresult;
91297 }
91298
91299
91300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91301   void * jresult ;
91302   Dali::BaseHandle arg1 ;
91303   Dali::BaseHandle *argp1 ;
91304   Dali::Toolkit::ToggleButton result;
91305
91306   argp1 = (Dali::BaseHandle *)jarg1;
91307   if (!argp1) {
91308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91309     return 0;
91310   }
91311   arg1 = *argp1;
91312   {
91313     try {
91314       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91315     } catch (std::out_of_range& e) {
91316       {
91317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91318       };
91319     } catch (std::exception& e) {
91320       {
91321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91322       };
91323     } catch (Dali::DaliException e) {
91324       {
91325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91326       };
91327     } catch (...) {
91328       {
91329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91330       };
91331     }
91332   }
91333
91334   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91335   return jresult;
91336 }
91337
91338
91339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91340   void * jresult ;
91341   Dali::Toolkit::Visual::Base *result = 0 ;
91342
91343   {
91344     try {
91345       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91346     } catch (std::out_of_range& e) {
91347       {
91348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91349       };
91350     } catch (std::exception& e) {
91351       {
91352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91353       };
91354     } catch (Dali::DaliException e) {
91355       {
91356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91357       };
91358     } catch (...) {
91359       {
91360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91361       };
91362     }
91363   }
91364
91365   jresult = (void *)result;
91366   return jresult;
91367 }
91368
91369
91370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91371   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91372
91373   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91374   {
91375     try {
91376       delete arg1;
91377     } catch (std::out_of_range& e) {
91378       {
91379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91380       };
91381     } catch (std::exception& e) {
91382       {
91383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91384       };
91385     } catch (Dali::DaliException e) {
91386       {
91387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91388       };
91389     } catch (...) {
91390       {
91391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91392       };
91393     }
91394   }
91395
91396 }
91397
91398
91399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91400   void * jresult ;
91401   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91402   Dali::Toolkit::Visual::Base *result = 0 ;
91403
91404   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91405   if (!arg1) {
91406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91407     return 0;
91408   }
91409   {
91410     try {
91411       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91412     } catch (std::out_of_range& e) {
91413       {
91414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91415       };
91416     } catch (std::exception& e) {
91417       {
91418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91419       };
91420     } catch (Dali::DaliException e) {
91421       {
91422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91423       };
91424     } catch (...) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91427       };
91428     }
91429   }
91430
91431   jresult = (void *)result;
91432   return jresult;
91433 }
91434
91435
91436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91437   void * jresult ;
91438   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91439   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91440   Dali::Toolkit::Visual::Base *result = 0 ;
91441
91442   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91443   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91444   if (!arg2) {
91445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91446     return 0;
91447   }
91448   {
91449     try {
91450       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91451     } catch (std::out_of_range& e) {
91452       {
91453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91454       };
91455     } catch (std::exception& e) {
91456       {
91457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91458       };
91459     } catch (Dali::DaliException e) {
91460       {
91461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91462       };
91463     } catch (...) {
91464       {
91465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91466       };
91467     }
91468   }
91469
91470   jresult = (void *)result;
91471   return jresult;
91472 }
91473
91474
91475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91476   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91477   std::string *arg2 = 0 ;
91478
91479   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91480   if (!jarg2) {
91481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91482     return ;
91483   }
91484   std::string arg2_str(jarg2);
91485   arg2 = &arg2_str;
91486   {
91487     try {
91488       (arg1)->SetName((std::string const &)*arg2);
91489     } catch (std::out_of_range& e) {
91490       {
91491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91492       };
91493     } catch (std::exception& e) {
91494       {
91495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91496       };
91497     } catch (Dali::DaliException e) {
91498       {
91499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91500       };
91501     } catch (...) {
91502       {
91503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91504       };
91505     }
91506   }
91507
91508
91509   //argout typemap for const std::string&
91510
91511 }
91512
91513
91514 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91515   char * jresult ;
91516   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91517   std::string *result = 0 ;
91518
91519   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91520   {
91521     try {
91522       result = (std::string *) &(arg1)->GetName();
91523     } catch (std::out_of_range& e) {
91524       {
91525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91526       };
91527     } catch (std::exception& e) {
91528       {
91529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91530       };
91531     } catch (Dali::DaliException e) {
91532       {
91533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91534       };
91535     } catch (...) {
91536       {
91537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91538       };
91539     }
91540   }
91541
91542   jresult = SWIG_csharp_string_callback(result->c_str());
91543   return jresult;
91544 }
91545
91546
91547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91548   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91549   Dali::Property::Map *arg2 = 0 ;
91550   Dali::Size arg3 ;
91551   Dali::Size *argp3 ;
91552
91553   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91554   arg2 = (Dali::Property::Map *)jarg2;
91555   if (!arg2) {
91556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91557     return ;
91558   }
91559   argp3 = (Dali::Size *)jarg3;
91560   if (!argp3) {
91561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91562     return ;
91563   }
91564   arg3 = *argp3;
91565   {
91566     try {
91567       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91568     } catch (std::out_of_range& e) {
91569       {
91570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91571       };
91572     } catch (std::exception& e) {
91573       {
91574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91575       };
91576     } catch (Dali::DaliException e) {
91577       {
91578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91579       };
91580     } catch (...) {
91581       {
91582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91583       };
91584     }
91585   }
91586
91587 }
91588
91589
91590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91591   float jresult ;
91592   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91593   float arg2 ;
91594   float result;
91595
91596   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91597   arg2 = (float)jarg2;
91598   {
91599     try {
91600       result = (float)(arg1)->GetHeightForWidth(arg2);
91601     } catch (std::out_of_range& e) {
91602       {
91603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91604       };
91605     } catch (std::exception& e) {
91606       {
91607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91608       };
91609     } catch (Dali::DaliException e) {
91610       {
91611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91612       };
91613     } catch (...) {
91614       {
91615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91616       };
91617     }
91618   }
91619
91620   jresult = result;
91621   return jresult;
91622 }
91623
91624
91625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91626   float jresult ;
91627   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91628   float arg2 ;
91629   float result;
91630
91631   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91632   arg2 = (float)jarg2;
91633   {
91634     try {
91635       result = (float)(arg1)->GetWidthForHeight(arg2);
91636     } catch (std::out_of_range& e) {
91637       {
91638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91639       };
91640     } catch (std::exception& e) {
91641       {
91642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91643       };
91644     } catch (Dali::DaliException e) {
91645       {
91646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91647       };
91648     } catch (...) {
91649       {
91650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91651       };
91652     }
91653   }
91654
91655   jresult = result;
91656   return jresult;
91657 }
91658
91659
91660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91661   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91662   Dali::Vector2 *arg2 = 0 ;
91663
91664   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91665   arg2 = (Dali::Vector2 *)jarg2;
91666   if (!arg2) {
91667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91668     return ;
91669   }
91670   {
91671     try {
91672       (arg1)->GetNaturalSize(*arg2);
91673     } catch (std::out_of_range& e) {
91674       {
91675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91676       };
91677     } catch (std::exception& e) {
91678       {
91679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91680       };
91681     } catch (Dali::DaliException e) {
91682       {
91683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91684       };
91685     } catch (...) {
91686       {
91687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91688       };
91689     }
91690   }
91691
91692 }
91693
91694
91695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91696   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91697   float arg2 ;
91698
91699   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91700   arg2 = (int)jarg2;
91701   {
91702     try {
91703       (arg1)->SetDepthIndex(arg2);
91704     } catch (std::out_of_range& e) {
91705       {
91706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91707       };
91708     } catch (std::exception& e) {
91709       {
91710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91711       };
91712     } catch (Dali::DaliException e) {
91713       {
91714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91715       };
91716     } catch (...) {
91717       {
91718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91719       };
91720     }
91721   }
91722
91723 }
91724
91725
91726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91727   int jresult ;
91728   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91729   int result;
91730
91731   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91732   {
91733     try {
91734       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91735     } catch (std::out_of_range& e) {
91736       {
91737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91738       };
91739     } catch (std::exception& e) {
91740       {
91741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91742       };
91743     } catch (Dali::DaliException e) {
91744       {
91745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91746       };
91747     } catch (...) {
91748       {
91749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91750       };
91751     }
91752   }
91753
91754   jresult = result;
91755   return jresult;
91756 }
91757
91758
91759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91760   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91761   Dali::Property::Map *arg2 = 0 ;
91762
91763   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91764   arg2 = (Dali::Property::Map *)jarg2;
91765   if (!arg2) {
91766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91767     return ;
91768   }
91769   {
91770     try {
91771       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91772     } catch (std::out_of_range& e) {
91773       {
91774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91775       };
91776     } catch (std::exception& e) {
91777       {
91778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91779       };
91780     } catch (Dali::DaliException e) {
91781       {
91782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91783       };
91784     } catch (...) {
91785       {
91786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91787       };
91788     }
91789   }
91790
91791 }
91792
91793
91794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91795   void * jresult ;
91796   Dali::Toolkit::VisualFactory result;
91797
91798   {
91799     try {
91800       result = Dali::Toolkit::VisualFactory::Get();
91801     } catch (std::out_of_range& e) {
91802       {
91803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91804       };
91805     } catch (std::exception& e) {
91806       {
91807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91808       };
91809     } catch (Dali::DaliException e) {
91810       {
91811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91812       };
91813     } catch (...) {
91814       {
91815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91816       };
91817     }
91818   }
91819
91820   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91821   return jresult;
91822 }
91823
91824
91825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91826   void * jresult ;
91827   Dali::Toolkit::VisualFactory *result = 0 ;
91828
91829   {
91830     try {
91831       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91832     } catch (std::out_of_range& e) {
91833       {
91834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91835       };
91836     } catch (std::exception& e) {
91837       {
91838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91839       };
91840     } catch (Dali::DaliException e) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91843       };
91844     } catch (...) {
91845       {
91846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91847       };
91848     }
91849   }
91850
91851   jresult = (void *)result;
91852   return jresult;
91853 }
91854
91855
91856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91857   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91858
91859   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91860   {
91861     try {
91862       delete arg1;
91863     } catch (std::out_of_range& e) {
91864       {
91865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91866       };
91867     } catch (std::exception& e) {
91868       {
91869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91870       };
91871     } catch (Dali::DaliException e) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91874       };
91875     } catch (...) {
91876       {
91877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91878       };
91879     }
91880   }
91881
91882 }
91883
91884
91885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91886   void * jresult ;
91887   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91888   Dali::Toolkit::VisualFactory *result = 0 ;
91889
91890   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91891   if (!arg1) {
91892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91893     return 0;
91894   }
91895   {
91896     try {
91897       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91898     } catch (std::out_of_range& e) {
91899       {
91900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91901       };
91902     } catch (std::exception& e) {
91903       {
91904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91905       };
91906     } catch (Dali::DaliException e) {
91907       {
91908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91909       };
91910     } catch (...) {
91911       {
91912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91913       };
91914     }
91915   }
91916
91917   jresult = (void *)result;
91918   return jresult;
91919 }
91920
91921
91922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91923   void * jresult ;
91924   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91925   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91926   Dali::Toolkit::VisualFactory *result = 0 ;
91927
91928   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91929   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91930   if (!arg2) {
91931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91932     return 0;
91933   }
91934   {
91935     try {
91936       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91937     } catch (std::out_of_range& e) {
91938       {
91939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91940       };
91941     } catch (std::exception& e) {
91942       {
91943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91944       };
91945     } catch (Dali::DaliException e) {
91946       {
91947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91948       };
91949     } catch (...) {
91950       {
91951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91952       };
91953     }
91954   }
91955
91956   jresult = (void *)result;
91957   return jresult;
91958 }
91959
91960
91961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91962   void * jresult ;
91963   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91964   Dali::Property::Map *arg2 = 0 ;
91965   Dali::Toolkit::Visual::Base result;
91966
91967   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91968   arg2 = (Dali::Property::Map *)jarg2;
91969   if (!arg2) {
91970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91971     return 0;
91972   }
91973   {
91974     try {
91975       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91976     } catch (std::out_of_range& e) {
91977       {
91978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91979       };
91980     } catch (std::exception& e) {
91981       {
91982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91983       };
91984     } catch (Dali::DaliException e) {
91985       {
91986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91987       };
91988     } catch (...) {
91989       {
91990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91991       };
91992     }
91993   }
91994
91995   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91996   return jresult;
91997 }
91998
91999
92000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
92001   void * jresult ;
92002   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92003   Dali::Image *arg2 = 0 ;
92004   Dali::Toolkit::Visual::Base result;
92005
92006   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92007   arg2 = (Dali::Image *)jarg2;
92008   if (!arg2) {
92009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
92010     return 0;
92011   }
92012   {
92013     try {
92014       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
92015     } catch (std::out_of_range& e) {
92016       {
92017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92018       };
92019     } catch (std::exception& e) {
92020       {
92021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92022       };
92023     } catch (Dali::DaliException e) {
92024       {
92025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92026       };
92027     } catch (...) {
92028       {
92029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92030       };
92031     }
92032   }
92033
92034   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92035   return jresult;
92036 }
92037
92038
92039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92040   void * jresult ;
92041   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92042   std::string *arg2 = 0 ;
92043   Dali::ImageDimensions arg3 ;
92044   Dali::ImageDimensions *argp3 ;
92045   Dali::Toolkit::Visual::Base result;
92046
92047   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92048   if (!jarg2) {
92049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92050     return 0;
92051   }
92052   std::string arg2_str(jarg2);
92053   arg2 = &arg2_str;
92054   argp3 = (Dali::ImageDimensions *)jarg3;
92055   if (!argp3) {
92056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92057     return 0;
92058   }
92059   arg3 = *argp3;
92060   {
92061     try {
92062       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92063     } catch (std::out_of_range& e) {
92064       {
92065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92066       };
92067     } catch (std::exception& e) {
92068       {
92069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92070       };
92071     } catch (Dali::DaliException e) {
92072       {
92073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92074       };
92075     } catch (...) {
92076       {
92077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92078       };
92079     }
92080   }
92081
92082   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92083
92084   //argout typemap for const std::string&
92085
92086   return jresult;
92087 }
92088
92089
92090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92091   void * jresult ;
92092   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92093
92094   {
92095     try {
92096       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92097     } catch (std::out_of_range& e) {
92098       {
92099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92100       };
92101     } catch (std::exception& e) {
92102       {
92103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92104       };
92105     } catch (Dali::DaliException e) {
92106       {
92107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92108       };
92109     } catch (...) {
92110       {
92111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92112       };
92113     }
92114   }
92115
92116   jresult = (void *)result;
92117   return jresult;
92118 }
92119
92120
92121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92122   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92123
92124   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92125   {
92126     try {
92127       delete arg1;
92128     } catch (std::out_of_range& e) {
92129       {
92130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92131       };
92132     } catch (std::exception& e) {
92133       {
92134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92135       };
92136     } catch (Dali::DaliException e) {
92137       {
92138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92139       };
92140     } catch (...) {
92141       {
92142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92143       };
92144     }
92145   }
92146
92147 }
92148
92149
92150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92151   void * jresult ;
92152   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92153   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92154
92155   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92156   if (!arg1) {
92157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92158     return 0;
92159   }
92160   {
92161     try {
92162       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92163     } catch (std::out_of_range& e) {
92164       {
92165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92166       };
92167     } catch (std::exception& e) {
92168       {
92169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92170       };
92171     } catch (Dali::DaliException e) {
92172       {
92173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92174       };
92175     } catch (...) {
92176       {
92177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92178       };
92179     }
92180   }
92181
92182   jresult = (void *)result;
92183   return jresult;
92184 }
92185
92186
92187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92188   void * jresult ;
92189   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92190   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92191   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92192
92193   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92194   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92195   if (!arg2) {
92196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92197     return 0;
92198   }
92199   {
92200     try {
92201       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92202     } catch (std::out_of_range& e) {
92203       {
92204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92205       };
92206     } catch (std::exception& e) {
92207       {
92208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92209       };
92210     } catch (Dali::DaliException e) {
92211       {
92212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92213       };
92214     } catch (...) {
92215       {
92216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92217       };
92218     }
92219   }
92220
92221   jresult = (void *)result;
92222   return jresult;
92223 }
92224
92225
92226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92227   void * jresult ;
92228   Dali::Toolkit::AsyncImageLoader result;
92229
92230   {
92231     try {
92232       result = Dali::Toolkit::AsyncImageLoader::New();
92233     } catch (std::out_of_range& e) {
92234       {
92235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92236       };
92237     } catch (std::exception& e) {
92238       {
92239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92240       };
92241     } catch (Dali::DaliException e) {
92242       {
92243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92244       };
92245     } catch (...) {
92246       {
92247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92248       };
92249     }
92250   }
92251
92252   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92253   return jresult;
92254 }
92255
92256
92257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92258   void * jresult ;
92259   Dali::BaseHandle arg1 ;
92260   Dali::BaseHandle *argp1 ;
92261   Dali::Toolkit::AsyncImageLoader result;
92262
92263   argp1 = (Dali::BaseHandle *)jarg1;
92264   if (!argp1) {
92265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92266     return 0;
92267   }
92268   arg1 = *argp1;
92269   {
92270     try {
92271       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92272     } catch (std::out_of_range& e) {
92273       {
92274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92275       };
92276     } catch (std::exception& e) {
92277       {
92278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92279       };
92280     } catch (Dali::DaliException e) {
92281       {
92282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92283       };
92284     } catch (...) {
92285       {
92286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92287       };
92288     }
92289   }
92290
92291   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92292   return jresult;
92293 }
92294
92295
92296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92297   unsigned int jresult ;
92298   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92299   std::string *arg2 = 0 ;
92300   uint32_t result;
92301
92302   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92303   if (!jarg2) {
92304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92305     return 0;
92306   }
92307   std::string arg2_str(jarg2);
92308   arg2 = &arg2_str;
92309   {
92310     try {
92311       result = (arg1)->Load((std::string const &)*arg2);
92312     } catch (std::out_of_range& e) {
92313       {
92314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92315       };
92316     } catch (std::exception& e) {
92317       {
92318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92319       };
92320     } catch (Dali::DaliException e) {
92321       {
92322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92323       };
92324     } catch (...) {
92325       {
92326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92327       };
92328     }
92329   }
92330
92331   jresult = result;
92332
92333   //argout typemap for const std::string&
92334
92335   return jresult;
92336 }
92337
92338
92339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92340   unsigned int jresult ;
92341   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92342   std::string *arg2 = 0 ;
92343   Dali::ImageDimensions arg3 ;
92344   Dali::ImageDimensions *argp3 ;
92345   uint32_t result;
92346
92347   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92348   if (!jarg2) {
92349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92350     return 0;
92351   }
92352   std::string arg2_str(jarg2);
92353   arg2 = &arg2_str;
92354   argp3 = (Dali::ImageDimensions *)jarg3;
92355   if (!argp3) {
92356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92357     return 0;
92358   }
92359   arg3 = *argp3;
92360   {
92361     try {
92362       result = (arg1)->Load((std::string const &)*arg2,arg3);
92363     } catch (std::out_of_range& e) {
92364       {
92365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92366       };
92367     } catch (std::exception& e) {
92368       {
92369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92370       };
92371     } catch (Dali::DaliException e) {
92372       {
92373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92374       };
92375     } catch (...) {
92376       {
92377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92378       };
92379     }
92380   }
92381
92382   jresult = result;
92383
92384   //argout typemap for const std::string&
92385
92386   return jresult;
92387 }
92388
92389
92390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92391   unsigned int jresult ;
92392   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92393   std::string *arg2 = 0 ;
92394   Dali::ImageDimensions arg3 ;
92395   Dali::FittingMode::Type arg4 ;
92396   Dali::SamplingMode::Type arg5 ;
92397   bool arg6 ;
92398   Dali::ImageDimensions *argp3 ;
92399   uint32_t result;
92400
92401   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92402   if (!jarg2) {
92403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92404     return 0;
92405   }
92406   std::string arg2_str(jarg2);
92407   arg2 = &arg2_str;
92408   argp3 = (Dali::ImageDimensions *)jarg3;
92409   if (!argp3) {
92410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92411     return 0;
92412   }
92413   arg3 = *argp3;
92414   arg4 = (Dali::FittingMode::Type)jarg4;
92415   arg5 = (Dali::SamplingMode::Type)jarg5;
92416   arg6 = jarg6 ? true : false;
92417   {
92418     try {
92419       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92420     } catch (std::out_of_range& e) {
92421       {
92422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92423       };
92424     } catch (std::exception& e) {
92425       {
92426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92427       };
92428     } catch (Dali::DaliException e) {
92429       {
92430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92431       };
92432     } catch (...) {
92433       {
92434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92435       };
92436     }
92437   }
92438
92439   jresult = result;
92440
92441   //argout typemap for const std::string&
92442
92443   return jresult;
92444 }
92445
92446
92447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92448   unsigned int jresult ;
92449   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92450   uint32_t arg2 ;
92451   bool result;
92452
92453   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92454   arg2 = (uint32_t)jarg2;
92455   {
92456     try {
92457       result = (bool)(arg1)->Cancel(arg2);
92458     } catch (std::out_of_range& e) {
92459       {
92460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92461       };
92462     } catch (std::exception& e) {
92463       {
92464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92465       };
92466     } catch (Dali::DaliException e) {
92467       {
92468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92469       };
92470     } catch (...) {
92471       {
92472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92473       };
92474     }
92475   }
92476
92477   jresult = result;
92478   return jresult;
92479 }
92480
92481
92482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92483   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92484
92485   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92486   {
92487     try {
92488       (arg1)->CancelAll();
92489     } catch (std::out_of_range& e) {
92490       {
92491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92492       };
92493     } catch (std::exception& e) {
92494       {
92495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92496       };
92497     } catch (Dali::DaliException e) {
92498       {
92499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92500       };
92501     } catch (...) {
92502       {
92503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92504       };
92505     }
92506   }
92507
92508 }
92509
92510
92511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92512   void * jresult ;
92513   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92514   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92515
92516   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92517   {
92518     try {
92519       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92520     } catch (std::out_of_range& e) {
92521       {
92522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92523       };
92524     } catch (std::exception& e) {
92525       {
92526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92527       };
92528     } catch (Dali::DaliException e) {
92529       {
92530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92531       };
92532     } catch (...) {
92533       {
92534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92535       };
92536     }
92537   }
92538
92539   jresult = (void *)result;
92540   return jresult;
92541 }
92542
92543
92544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92545   void * jresult ;
92546   std::string *arg1 = 0 ;
92547   Dali::PixelData result;
92548
92549   if (!jarg1) {
92550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92551     return 0;
92552   }
92553   std::string arg1_str(jarg1);
92554   arg1 = &arg1_str;
92555   {
92556     try {
92557       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92558     } catch (std::out_of_range& e) {
92559       {
92560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92561       };
92562     } catch (std::exception& e) {
92563       {
92564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92565       };
92566     } catch (Dali::DaliException e) {
92567       {
92568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92569       };
92570     } catch (...) {
92571       {
92572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92573       };
92574     }
92575   }
92576
92577   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92578
92579   //argout typemap for const std::string&
92580
92581   return jresult;
92582 }
92583
92584
92585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92586   void * jresult ;
92587   std::string *arg1 = 0 ;
92588   Dali::ImageDimensions arg2 ;
92589   Dali::ImageDimensions *argp2 ;
92590   Dali::PixelData result;
92591
92592   if (!jarg1) {
92593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92594     return 0;
92595   }
92596   std::string arg1_str(jarg1);
92597   arg1 = &arg1_str;
92598   argp2 = (Dali::ImageDimensions *)jarg2;
92599   if (!argp2) {
92600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92601     return 0;
92602   }
92603   arg2 = *argp2;
92604   {
92605     try {
92606       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92607     } catch (std::out_of_range& e) {
92608       {
92609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92610       };
92611     } catch (std::exception& e) {
92612       {
92613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92614       };
92615     } catch (Dali::DaliException e) {
92616       {
92617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92618       };
92619     } catch (...) {
92620       {
92621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92622       };
92623     }
92624   }
92625
92626   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92627
92628   //argout typemap for const std::string&
92629
92630   return jresult;
92631 }
92632
92633
92634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92635   void * jresult ;
92636   std::string *arg1 = 0 ;
92637   Dali::ImageDimensions arg2 ;
92638   Dali::FittingMode::Type arg3 ;
92639   Dali::SamplingMode::Type arg4 ;
92640   bool arg5 ;
92641   Dali::ImageDimensions *argp2 ;
92642   Dali::PixelData result;
92643
92644   if (!jarg1) {
92645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92646     return 0;
92647   }
92648   std::string arg1_str(jarg1);
92649   arg1 = &arg1_str;
92650   argp2 = (Dali::ImageDimensions *)jarg2;
92651   if (!argp2) {
92652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92653     return 0;
92654   }
92655   arg2 = *argp2;
92656   arg3 = (Dali::FittingMode::Type)jarg3;
92657   arg4 = (Dali::SamplingMode::Type)jarg4;
92658   arg5 = jarg5 ? true : false;
92659   {
92660     try {
92661       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92662     } catch (std::out_of_range& e) {
92663       {
92664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92665       };
92666     } catch (std::exception& e) {
92667       {
92668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92669       };
92670     } catch (Dali::DaliException e) {
92671       {
92672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92673       };
92674     } catch (...) {
92675       {
92676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92677       };
92678     }
92679   }
92680
92681   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92682
92683   //argout typemap for const std::string&
92684
92685   return jresult;
92686 }
92687
92688
92689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92690   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92691
92692   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92693   {
92694     try {
92695       delete arg1;
92696     } catch (std::out_of_range& e) {
92697       {
92698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92699       };
92700     } catch (std::exception& e) {
92701       {
92702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92703       };
92704     } catch (Dali::DaliException e) {
92705       {
92706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92707       };
92708     } catch (...) {
92709       {
92710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92711       };
92712     }
92713   }
92714
92715 }
92716
92717
92718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92719   void * jresult ;
92720   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92721   Dali::Actor arg2 ;
92722   Dali::Actor arg3 ;
92723   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92724   Dali::Actor *argp2 ;
92725   Dali::Actor *argp3 ;
92726   Dali::Actor result;
92727
92728   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92729   argp2 = (Dali::Actor *)jarg2;
92730   if (!argp2) {
92731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92732     return 0;
92733   }
92734   arg2 = *argp2;
92735   argp3 = (Dali::Actor *)jarg3;
92736   if (!argp3) {
92737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92738     return 0;
92739   }
92740   arg3 = *argp3;
92741   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92742   {
92743     try {
92744       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92745     } catch (std::out_of_range& e) {
92746       {
92747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92748       };
92749     } catch (std::exception& e) {
92750       {
92751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92752       };
92753     } catch (Dali::DaliException e) {
92754       {
92755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92756       };
92757     } catch (...) {
92758       {
92759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92760       };
92761     }
92762   }
92763
92764   jresult = new Dali::Actor((const Dali::Actor &)result);
92765   return jresult;
92766 }
92767
92768
92769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92770   void * jresult ;
92771   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92772
92773   {
92774     try {
92775       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92776     } catch (std::out_of_range& e) {
92777       {
92778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92779       };
92780     } catch (std::exception& e) {
92781       {
92782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92783       };
92784     } catch (Dali::DaliException e) {
92785       {
92786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92787       };
92788     } catch (...) {
92789       {
92790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92791       };
92792     }
92793   }
92794
92795   jresult = (void *)result;
92796   return jresult;
92797 }
92798
92799
92800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92801   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92802   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92803   if (director) {
92804     director->swig_connect_director(callback0);
92805   }
92806 }
92807
92808
92809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92810   KeyboardFocusManager arg1 ;
92811   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92812   KeyboardFocusManager *argp1 ;
92813
92814   argp1 = (KeyboardFocusManager *)jarg1;
92815   if (!argp1) {
92816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92817     return ;
92818   }
92819   arg1 = *argp1;
92820   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92821   if (!arg2) {
92822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92823     return ;
92824   }
92825   {
92826     try {
92827       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92828     } catch (std::out_of_range& e) {
92829       {
92830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92831       };
92832     } catch (std::exception& e) {
92833       {
92834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92835       };
92836     } catch (Dali::DaliException e) {
92837       {
92838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92839       };
92840     } catch (...) {
92841       {
92842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92843       };
92844     }
92845   }
92846
92847 }
92848
92849
92850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92851   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92852
92853   arg1 = (std::vector< unsigned int > *)jarg1;
92854   {
92855     try {
92856       (arg1)->clear();
92857     } catch (std::out_of_range& e) {
92858       {
92859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92860       };
92861     } catch (std::exception& e) {
92862       {
92863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92864       };
92865     } catch (Dali::DaliException e) {
92866       {
92867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92868       };
92869     } catch (...) {
92870       {
92871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92872       };
92873     }
92874   }
92875
92876 }
92877
92878
92879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92880   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92881   unsigned int *arg2 = 0 ;
92882   unsigned int temp2 ;
92883
92884   arg1 = (std::vector< unsigned int > *)jarg1;
92885   temp2 = (unsigned int)jarg2;
92886   arg2 = &temp2;
92887   {
92888     try {
92889       (arg1)->push_back((unsigned int const &)*arg2);
92890     } catch (std::out_of_range& e) {
92891       {
92892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92893       };
92894     } catch (std::exception& e) {
92895       {
92896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92897       };
92898     } catch (Dali::DaliException e) {
92899       {
92900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92901       };
92902     } catch (...) {
92903       {
92904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92905       };
92906     }
92907   }
92908
92909 }
92910
92911
92912 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92913   unsigned long jresult ;
92914   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92915   std::vector< unsigned int >::size_type result;
92916
92917   arg1 = (std::vector< unsigned int > *)jarg1;
92918   {
92919     try {
92920       result = ((std::vector< unsigned int > const *)arg1)->size();
92921     } catch (std::out_of_range& e) {
92922       {
92923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92924       };
92925     } catch (std::exception& e) {
92926       {
92927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92928       };
92929     } catch (Dali::DaliException e) {
92930       {
92931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92932       };
92933     } catch (...) {
92934       {
92935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92936       };
92937     }
92938   }
92939
92940   jresult = (unsigned long)result;
92941   return jresult;
92942 }
92943
92944
92945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92946   unsigned long jresult ;
92947   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92948   std::vector< unsigned int >::size_type result;
92949
92950   arg1 = (std::vector< unsigned int > *)jarg1;
92951   {
92952     try {
92953       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92954     } catch (std::out_of_range& e) {
92955       {
92956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92957       };
92958     } catch (std::exception& e) {
92959       {
92960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92961       };
92962     } catch (Dali::DaliException e) {
92963       {
92964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92965       };
92966     } catch (...) {
92967       {
92968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92969       };
92970     }
92971   }
92972
92973   jresult = (unsigned long)result;
92974   return jresult;
92975 }
92976
92977
92978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92979   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92980   std::vector< unsigned int >::size_type arg2 ;
92981
92982   arg1 = (std::vector< unsigned int > *)jarg1;
92983   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92984   {
92985     try {
92986       (arg1)->reserve(arg2);
92987     } catch (std::out_of_range& e) {
92988       {
92989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92990       };
92991     } catch (std::exception& e) {
92992       {
92993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92994       };
92995     } catch (Dali::DaliException e) {
92996       {
92997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92998       };
92999     } catch (...) {
93000       {
93001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93002       };
93003     }
93004   }
93005
93006 }
93007
93008
93009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
93010   void * jresult ;
93011   std::vector< unsigned int > *result = 0 ;
93012
93013   {
93014     try {
93015       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93016     } catch (std::out_of_range& e) {
93017       {
93018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93019       };
93020     } catch (std::exception& e) {
93021       {
93022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93023       };
93024     } catch (Dali::DaliException e) {
93025       {
93026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93027       };
93028     } catch (...) {
93029       {
93030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93031       };
93032     }
93033   }
93034
93035   jresult = (void *)result;
93036   return jresult;
93037 }
93038
93039
93040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93041   void * jresult ;
93042   std::vector< unsigned int > *arg1 = 0 ;
93043   std::vector< unsigned int > *result = 0 ;
93044
93045   arg1 = (std::vector< unsigned int > *)jarg1;
93046   if (!arg1) {
93047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93048     return 0;
93049   }
93050   {
93051     try {
93052       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93053     } catch (std::out_of_range& e) {
93054       {
93055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93056       };
93057     } catch (std::exception& e) {
93058       {
93059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93060       };
93061     } catch (Dali::DaliException e) {
93062       {
93063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93064       };
93065     } catch (...) {
93066       {
93067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93068       };
93069     }
93070   }
93071
93072   jresult = (void *)result;
93073   return jresult;
93074 }
93075
93076
93077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93078   void * jresult ;
93079   int arg1 ;
93080   std::vector< unsigned int > *result = 0 ;
93081
93082   arg1 = (int)jarg1;
93083   {
93084     try {
93085       try {
93086         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93087       }
93088       catch(std::out_of_range &_e) {
93089         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93090         return 0;
93091       }
93092
93093     } catch (std::out_of_range& e) {
93094       {
93095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93096       };
93097     } catch (std::exception& e) {
93098       {
93099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93100       };
93101     } catch (Dali::DaliException e) {
93102       {
93103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93104       };
93105     } catch (...) {
93106       {
93107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93108       };
93109     }
93110   }
93111
93112   jresult = (void *)result;
93113   return jresult;
93114 }
93115
93116
93117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93118   unsigned int jresult ;
93119   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93120   int arg2 ;
93121   unsigned int result;
93122
93123   arg1 = (std::vector< unsigned int > *)jarg1;
93124   arg2 = (int)jarg2;
93125   {
93126     try {
93127       try {
93128         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93129       }
93130       catch(std::out_of_range &_e) {
93131         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93132         return 0;
93133       }
93134
93135     } catch (std::out_of_range& e) {
93136       {
93137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93138       };
93139     } catch (std::exception& e) {
93140       {
93141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93142       };
93143     } catch (Dali::DaliException e) {
93144       {
93145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93146       };
93147     } catch (...) {
93148       {
93149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93150       };
93151     }
93152   }
93153
93154   jresult = result;
93155   return jresult;
93156 }
93157
93158
93159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93160   unsigned int jresult ;
93161   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93162   int arg2 ;
93163   unsigned int *result = 0 ;
93164
93165   arg1 = (std::vector< unsigned int > *)jarg1;
93166   arg2 = (int)jarg2;
93167   {
93168     try {
93169       try {
93170         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93171       }
93172       catch(std::out_of_range &_e) {
93173         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93174         return 0;
93175       }
93176
93177     } catch (std::out_of_range& e) {
93178       {
93179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93180       };
93181     } catch (std::exception& e) {
93182       {
93183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93184       };
93185     } catch (Dali::DaliException e) {
93186       {
93187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93188       };
93189     } catch (...) {
93190       {
93191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93192       };
93193     }
93194   }
93195
93196   jresult = *result;
93197   return jresult;
93198 }
93199
93200
93201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93202   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93203   int arg2 ;
93204   unsigned int *arg3 = 0 ;
93205   unsigned int temp3 ;
93206
93207   arg1 = (std::vector< unsigned int > *)jarg1;
93208   arg2 = (int)jarg2;
93209   temp3 = (unsigned int)jarg3;
93210   arg3 = &temp3;
93211   {
93212     try {
93213       try {
93214         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93215       }
93216       catch(std::out_of_range &_e) {
93217         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93218         return ;
93219       }
93220
93221     } catch (std::out_of_range& e) {
93222       {
93223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93224       };
93225     } catch (std::exception& e) {
93226       {
93227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93228       };
93229     } catch (Dali::DaliException e) {
93230       {
93231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93232       };
93233     } catch (...) {
93234       {
93235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93236       };
93237     }
93238   }
93239
93240 }
93241
93242
93243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93244   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93245   std::vector< unsigned int > *arg2 = 0 ;
93246
93247   arg1 = (std::vector< unsigned int > *)jarg1;
93248   arg2 = (std::vector< unsigned int > *)jarg2;
93249   if (!arg2) {
93250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93251     return ;
93252   }
93253   {
93254     try {
93255       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93256     } catch (std::out_of_range& e) {
93257       {
93258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93259       };
93260     } catch (std::exception& e) {
93261       {
93262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93263       };
93264     } catch (Dali::DaliException e) {
93265       {
93266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93267       };
93268     } catch (...) {
93269       {
93270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93271       };
93272     }
93273   }
93274
93275 }
93276
93277
93278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93279   void * jresult ;
93280   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93281   int arg2 ;
93282   int arg3 ;
93283   std::vector< unsigned int > *result = 0 ;
93284
93285   arg1 = (std::vector< unsigned int > *)jarg1;
93286   arg2 = (int)jarg2;
93287   arg3 = (int)jarg3;
93288   {
93289     try {
93290       try {
93291         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93292       }
93293       catch(std::out_of_range &_e) {
93294         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93295         return 0;
93296       }
93297       catch(std::invalid_argument &_e) {
93298         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93299         return 0;
93300       }
93301
93302     } catch (std::out_of_range& e) {
93303       {
93304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93305       };
93306     } catch (std::exception& e) {
93307       {
93308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93309       };
93310     } catch (Dali::DaliException e) {
93311       {
93312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93313       };
93314     } catch (...) {
93315       {
93316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93317       };
93318     }
93319   }
93320
93321   jresult = (void *)result;
93322   return jresult;
93323 }
93324
93325
93326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93327   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93328   int arg2 ;
93329   unsigned int *arg3 = 0 ;
93330   unsigned int temp3 ;
93331
93332   arg1 = (std::vector< unsigned int > *)jarg1;
93333   arg2 = (int)jarg2;
93334   temp3 = (unsigned int)jarg3;
93335   arg3 = &temp3;
93336   {
93337     try {
93338       try {
93339         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93340       }
93341       catch(std::out_of_range &_e) {
93342         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93343         return ;
93344       }
93345
93346     } catch (std::out_of_range& e) {
93347       {
93348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93349       };
93350     } catch (std::exception& e) {
93351       {
93352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93353       };
93354     } catch (Dali::DaliException e) {
93355       {
93356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93357       };
93358     } catch (...) {
93359       {
93360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93361       };
93362     }
93363   }
93364
93365 }
93366
93367
93368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93369   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93370   int arg2 ;
93371   std::vector< unsigned int > *arg3 = 0 ;
93372
93373   arg1 = (std::vector< unsigned int > *)jarg1;
93374   arg2 = (int)jarg2;
93375   arg3 = (std::vector< unsigned int > *)jarg3;
93376   if (!arg3) {
93377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93378     return ;
93379   }
93380   {
93381     try {
93382       try {
93383         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93384       }
93385       catch(std::out_of_range &_e) {
93386         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93387         return ;
93388       }
93389
93390     } catch (std::out_of_range& e) {
93391       {
93392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93393       };
93394     } catch (std::exception& e) {
93395       {
93396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93397       };
93398     } catch (Dali::DaliException e) {
93399       {
93400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93401       };
93402     } catch (...) {
93403       {
93404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93405       };
93406     }
93407   }
93408
93409 }
93410
93411
93412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93413   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93414   int arg2 ;
93415
93416   arg1 = (std::vector< unsigned int > *)jarg1;
93417   arg2 = (int)jarg2;
93418   {
93419     try {
93420       try {
93421         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93422       }
93423       catch(std::out_of_range &_e) {
93424         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93425         return ;
93426       }
93427
93428     } catch (std::out_of_range& e) {
93429       {
93430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93431       };
93432     } catch (std::exception& e) {
93433       {
93434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93435       };
93436     } catch (Dali::DaliException e) {
93437       {
93438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93439       };
93440     } catch (...) {
93441       {
93442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93443       };
93444     }
93445   }
93446
93447 }
93448
93449
93450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93451   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93452   int arg2 ;
93453   int arg3 ;
93454
93455   arg1 = (std::vector< unsigned int > *)jarg1;
93456   arg2 = (int)jarg2;
93457   arg3 = (int)jarg3;
93458   {
93459     try {
93460       try {
93461         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93462       }
93463       catch(std::out_of_range &_e) {
93464         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93465         return ;
93466       }
93467       catch(std::invalid_argument &_e) {
93468         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93469         return ;
93470       }
93471
93472     } catch (std::out_of_range& e) {
93473       {
93474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93475       };
93476     } catch (std::exception& e) {
93477       {
93478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93479       };
93480     } catch (Dali::DaliException e) {
93481       {
93482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93483       };
93484     } catch (...) {
93485       {
93486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93487       };
93488     }
93489   }
93490
93491 }
93492
93493
93494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93495   void * jresult ;
93496   unsigned int *arg1 = 0 ;
93497   int arg2 ;
93498   unsigned int temp1 ;
93499   std::vector< unsigned int > *result = 0 ;
93500
93501   temp1 = (unsigned int)jarg1;
93502   arg1 = &temp1;
93503   arg2 = (int)jarg2;
93504   {
93505     try {
93506       try {
93507         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93508       }
93509       catch(std::out_of_range &_e) {
93510         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93511         return 0;
93512       }
93513
93514     } catch (std::out_of_range& e) {
93515       {
93516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93517       };
93518     } catch (std::exception& e) {
93519       {
93520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93521       };
93522     } catch (Dali::DaliException e) {
93523       {
93524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93525       };
93526     } catch (...) {
93527       {
93528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93529       };
93530     }
93531   }
93532
93533   jresult = (void *)result;
93534   return jresult;
93535 }
93536
93537
93538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93539   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93540
93541   arg1 = (std::vector< unsigned int > *)jarg1;
93542   {
93543     try {
93544       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93545     } catch (std::out_of_range& e) {
93546       {
93547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93548       };
93549     } catch (std::exception& e) {
93550       {
93551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93552       };
93553     } catch (Dali::DaliException e) {
93554       {
93555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93556       };
93557     } catch (...) {
93558       {
93559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93560       };
93561     }
93562   }
93563
93564 }
93565
93566
93567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93568   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93569   int arg2 ;
93570   int arg3 ;
93571
93572   arg1 = (std::vector< unsigned int > *)jarg1;
93573   arg2 = (int)jarg2;
93574   arg3 = (int)jarg3;
93575   {
93576     try {
93577       try {
93578         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93579       }
93580       catch(std::out_of_range &_e) {
93581         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93582         return ;
93583       }
93584       catch(std::invalid_argument &_e) {
93585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93586         return ;
93587       }
93588
93589     } catch (std::out_of_range& e) {
93590       {
93591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93592       };
93593     } catch (std::exception& e) {
93594       {
93595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93596       };
93597     } catch (Dali::DaliException e) {
93598       {
93599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93600       };
93601     } catch (...) {
93602       {
93603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93604       };
93605     }
93606   }
93607
93608 }
93609
93610
93611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93612   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93613   int arg2 ;
93614   std::vector< unsigned int > *arg3 = 0 ;
93615
93616   arg1 = (std::vector< unsigned int > *)jarg1;
93617   arg2 = (int)jarg2;
93618   arg3 = (std::vector< unsigned int > *)jarg3;
93619   if (!arg3) {
93620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93621     return ;
93622   }
93623   {
93624     try {
93625       try {
93626         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93627       }
93628       catch(std::out_of_range &_e) {
93629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93630         return ;
93631       }
93632
93633     } catch (std::out_of_range& e) {
93634       {
93635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93636       };
93637     } catch (std::exception& e) {
93638       {
93639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93640       };
93641     } catch (Dali::DaliException e) {
93642       {
93643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93644       };
93645     } catch (...) {
93646       {
93647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93648       };
93649     }
93650   }
93651
93652 }
93653
93654
93655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93656   unsigned int jresult ;
93657   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93658   unsigned int *arg2 = 0 ;
93659   unsigned int temp2 ;
93660   bool result;
93661
93662   arg1 = (std::vector< unsigned int > *)jarg1;
93663   temp2 = (unsigned int)jarg2;
93664   arg2 = &temp2;
93665   {
93666     try {
93667       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93668     } catch (std::out_of_range& e) {
93669       {
93670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93671       };
93672     } catch (std::exception& e) {
93673       {
93674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93675       };
93676     } catch (Dali::DaliException e) {
93677       {
93678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93679       };
93680     } catch (...) {
93681       {
93682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93683       };
93684     }
93685   }
93686
93687   jresult = result;
93688   return jresult;
93689 }
93690
93691
93692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93693   int jresult ;
93694   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93695   unsigned int *arg2 = 0 ;
93696   unsigned int temp2 ;
93697   int result;
93698
93699   arg1 = (std::vector< unsigned int > *)jarg1;
93700   temp2 = (unsigned int)jarg2;
93701   arg2 = &temp2;
93702   {
93703     try {
93704       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93705     } catch (std::out_of_range& e) {
93706       {
93707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93708       };
93709     } catch (std::exception& e) {
93710       {
93711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93712       };
93713     } catch (Dali::DaliException e) {
93714       {
93715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93716       };
93717     } catch (...) {
93718       {
93719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93720       };
93721     }
93722   }
93723
93724   jresult = result;
93725   return jresult;
93726 }
93727
93728
93729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93730   int jresult ;
93731   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93732   unsigned int *arg2 = 0 ;
93733   unsigned int temp2 ;
93734   int result;
93735
93736   arg1 = (std::vector< unsigned int > *)jarg1;
93737   temp2 = (unsigned int)jarg2;
93738   arg2 = &temp2;
93739   {
93740     try {
93741       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93742     } catch (std::out_of_range& e) {
93743       {
93744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93745       };
93746     } catch (std::exception& e) {
93747       {
93748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93749       };
93750     } catch (Dali::DaliException e) {
93751       {
93752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93753       };
93754     } catch (...) {
93755       {
93756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93757       };
93758     }
93759   }
93760
93761   jresult = result;
93762   return jresult;
93763 }
93764
93765
93766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93767   unsigned int jresult ;
93768   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93769   unsigned int *arg2 = 0 ;
93770   unsigned int temp2 ;
93771   bool result;
93772
93773   arg1 = (std::vector< unsigned int > *)jarg1;
93774   temp2 = (unsigned int)jarg2;
93775   arg2 = &temp2;
93776   {
93777     try {
93778       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93779     } catch (std::out_of_range& e) {
93780       {
93781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93782       };
93783     } catch (std::exception& e) {
93784       {
93785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93786       };
93787     } catch (Dali::DaliException e) {
93788       {
93789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93790       };
93791     } catch (...) {
93792       {
93793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93794       };
93795     }
93796   }
93797
93798   jresult = result;
93799   return jresult;
93800 }
93801
93802
93803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93804   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93805
93806   arg1 = (std::vector< unsigned int > *)jarg1;
93807   {
93808     try {
93809       delete arg1;
93810     } catch (std::out_of_range& e) {
93811       {
93812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93813       };
93814     } catch (std::exception& e) {
93815       {
93816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93817       };
93818     } catch (Dali::DaliException e) {
93819       {
93820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93821       };
93822     } catch (...) {
93823       {
93824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93825       };
93826     }
93827   }
93828
93829 }
93830
93831
93832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93833   void * jresult ;
93834   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93835
93836   {
93837     try {
93838       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93839     } catch (std::out_of_range& e) {
93840       {
93841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93842       };
93843     } catch (std::exception& e) {
93844       {
93845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93846       };
93847     } catch (Dali::DaliException e) {
93848       {
93849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93850       };
93851     } catch (...) {
93852       {
93853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93854       };
93855     }
93856   }
93857
93858   jresult = (void *)result;
93859   return jresult;
93860 }
93861
93862
93863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93864   void * jresult ;
93865   unsigned int arg1 ;
93866   Dali::Actor arg2 ;
93867   Dali::Actor *argp2 ;
93868   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93869
93870   arg1 = (unsigned int)jarg1;
93871   argp2 = (Dali::Actor *)jarg2;
93872   if (!argp2) {
93873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93874     return 0;
93875   }
93876   arg2 = *argp2;
93877   {
93878     try {
93879       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93880     } catch (std::out_of_range& e) {
93881       {
93882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93883       };
93884     } catch (std::exception& e) {
93885       {
93886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93887       };
93888     } catch (Dali::DaliException e) {
93889       {
93890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93891       };
93892     } catch (...) {
93893       {
93894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93895       };
93896     }
93897   }
93898
93899   jresult = (void *)result;
93900   return jresult;
93901 }
93902
93903
93904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93905   void * jresult ;
93906   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93907   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93908
93909   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93910   if (!arg1) {
93911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93912     return 0;
93913   }
93914   {
93915     try {
93916       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93917     } catch (std::out_of_range& e) {
93918       {
93919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93920       };
93921     } catch (std::exception& e) {
93922       {
93923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93924       };
93925     } catch (Dali::DaliException e) {
93926       {
93927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93928       };
93929     } catch (...) {
93930       {
93931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93932       };
93933     }
93934   }
93935
93936   jresult = (void *)result;
93937   return jresult;
93938 }
93939
93940
93941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93942   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93943   unsigned int arg2 ;
93944
93945   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93946   arg2 = (unsigned int)jarg2;
93947   if (arg1) (arg1)->first = arg2;
93948 }
93949
93950
93951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93952   unsigned int jresult ;
93953   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93954   unsigned int result;
93955
93956   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93957   result = (unsigned int) ((arg1)->first);
93958   jresult = result;
93959   return jresult;
93960 }
93961
93962
93963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93964   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93965   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93966
93967   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93968   arg2 = (Dali::Actor *)jarg2;
93969   if (arg1) (arg1)->second = *arg2;
93970 }
93971
93972
93973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93974   void * jresult ;
93975   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93976   Dali::Actor *result = 0 ;
93977
93978   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93979   result = (Dali::Actor *)& ((arg1)->second);
93980   jresult = (void *)result;
93981   return jresult;
93982 }
93983
93984
93985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93986   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93987
93988   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93989   {
93990     try {
93991       delete arg1;
93992     } catch (std::out_of_range& e) {
93993       {
93994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93995       };
93996     } catch (std::exception& e) {
93997       {
93998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93999       };
94000     } catch (Dali::DaliException e) {
94001       {
94002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94003       };
94004     } catch (...) {
94005       {
94006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94007       };
94008     }
94009   }
94010
94011 }
94012
94013
94014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94015   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94016
94017   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94018   {
94019     try {
94020       (arg1)->clear();
94021     } catch (std::out_of_range& e) {
94022       {
94023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94024       };
94025     } catch (std::exception& e) {
94026       {
94027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94028       };
94029     } catch (Dali::DaliException e) {
94030       {
94031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94032       };
94033     } catch (...) {
94034       {
94035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94036       };
94037     }
94038   }
94039
94040 }
94041
94042
94043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94044   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94045   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94046
94047   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94048   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94049   if (!arg2) {
94050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94051     return ;
94052   }
94053   {
94054     try {
94055       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94056     } catch (std::out_of_range& e) {
94057       {
94058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94059       };
94060     } catch (std::exception& e) {
94061       {
94062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94063       };
94064     } catch (Dali::DaliException e) {
94065       {
94066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94067       };
94068     } catch (...) {
94069       {
94070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94071       };
94072     }
94073   }
94074
94075 }
94076
94077
94078 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94079   unsigned long jresult ;
94080   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94081   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94082
94083   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94084   {
94085     try {
94086       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94087     } catch (std::out_of_range& e) {
94088       {
94089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94090       };
94091     } catch (std::exception& e) {
94092       {
94093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94094       };
94095     } catch (Dali::DaliException e) {
94096       {
94097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94098       };
94099     } catch (...) {
94100       {
94101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94102       };
94103     }
94104   }
94105
94106   jresult = (unsigned long)result;
94107   return jresult;
94108 }
94109
94110
94111 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94112   unsigned long jresult ;
94113   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94114   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94115
94116   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94117   {
94118     try {
94119       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94120     } catch (std::out_of_range& e) {
94121       {
94122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94123       };
94124     } catch (std::exception& e) {
94125       {
94126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94127       };
94128     } catch (Dali::DaliException e) {
94129       {
94130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94131       };
94132     } catch (...) {
94133       {
94134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94135       };
94136     }
94137   }
94138
94139   jresult = (unsigned long)result;
94140   return jresult;
94141 }
94142
94143
94144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94145   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94146   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94147
94148   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94149   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94150   {
94151     try {
94152       (arg1)->reserve(arg2);
94153     } catch (std::out_of_range& e) {
94154       {
94155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94156       };
94157     } catch (std::exception& e) {
94158       {
94159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94160       };
94161     } catch (Dali::DaliException e) {
94162       {
94163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94164       };
94165     } catch (...) {
94166       {
94167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94168       };
94169     }
94170   }
94171
94172 }
94173
94174
94175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94176   void * jresult ;
94177   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94178
94179   {
94180     try {
94181       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94182     } catch (std::out_of_range& e) {
94183       {
94184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94185       };
94186     } catch (std::exception& e) {
94187       {
94188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94189       };
94190     } catch (Dali::DaliException e) {
94191       {
94192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94193       };
94194     } catch (...) {
94195       {
94196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94197       };
94198     }
94199   }
94200
94201   jresult = (void *)result;
94202   return jresult;
94203 }
94204
94205
94206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94207   void * jresult ;
94208   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94209   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94210
94211   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94212   if (!arg1) {
94213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94214     return 0;
94215   }
94216   {
94217     try {
94218       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);
94219     } catch (std::out_of_range& e) {
94220       {
94221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94222       };
94223     } catch (std::exception& e) {
94224       {
94225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94226       };
94227     } catch (Dali::DaliException e) {
94228       {
94229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94230       };
94231     } catch (...) {
94232       {
94233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94234       };
94235     }
94236   }
94237
94238   jresult = (void *)result;
94239   return jresult;
94240 }
94241
94242
94243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94244   void * jresult ;
94245   int arg1 ;
94246   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94247
94248   arg1 = (int)jarg1;
94249   {
94250     try {
94251       try {
94252         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);
94253       }
94254       catch(std::out_of_range &_e) {
94255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94256         return 0;
94257       }
94258
94259     } catch (std::out_of_range& e) {
94260       {
94261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94262       };
94263     } catch (std::exception& e) {
94264       {
94265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94266       };
94267     } catch (Dali::DaliException e) {
94268       {
94269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94270       };
94271     } catch (...) {
94272       {
94273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94274       };
94275     }
94276   }
94277
94278   jresult = (void *)result;
94279   return jresult;
94280 }
94281
94282
94283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94284   void * jresult ;
94285   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94286   int arg2 ;
94287   std::pair< unsigned int,Dali::Actor > result;
94288
94289   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94290   arg2 = (int)jarg2;
94291   {
94292     try {
94293       try {
94294         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94295       }
94296       catch(std::out_of_range &_e) {
94297         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94298         return 0;
94299       }
94300
94301     } catch (std::out_of_range& e) {
94302       {
94303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94304       };
94305     } catch (std::exception& e) {
94306       {
94307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94308       };
94309     } catch (Dali::DaliException e) {
94310       {
94311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94312       };
94313     } catch (...) {
94314       {
94315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94316       };
94317     }
94318   }
94319
94320   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94321   return jresult;
94322 }
94323
94324
94325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94326   void * jresult ;
94327   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94328   int arg2 ;
94329   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94330
94331   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94332   arg2 = (int)jarg2;
94333   {
94334     try {
94335       try {
94336         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94337       }
94338       catch(std::out_of_range &_e) {
94339         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94340         return 0;
94341       }
94342
94343     } catch (std::out_of_range& e) {
94344       {
94345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94346       };
94347     } catch (std::exception& e) {
94348       {
94349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94350       };
94351     } catch (Dali::DaliException e) {
94352       {
94353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94354       };
94355     } catch (...) {
94356       {
94357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94358       };
94359     }
94360   }
94361
94362   jresult = (void *)result;
94363   return jresult;
94364 }
94365
94366
94367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94368   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94369   int arg2 ;
94370   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94371
94372   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94373   arg2 = (int)jarg2;
94374   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94375   if (!arg3) {
94376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94377     return ;
94378   }
94379   {
94380     try {
94381       try {
94382         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);
94383       }
94384       catch(std::out_of_range &_e) {
94385         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94386         return ;
94387       }
94388
94389     } catch (std::out_of_range& e) {
94390       {
94391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94392       };
94393     } catch (std::exception& e) {
94394       {
94395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94396       };
94397     } catch (Dali::DaliException e) {
94398       {
94399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94400       };
94401     } catch (...) {
94402       {
94403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94404       };
94405     }
94406   }
94407
94408 }
94409
94410
94411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94412   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94413   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94414
94415   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94416   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94417   if (!arg2) {
94418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94419     return ;
94420   }
94421   {
94422     try {
94423       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);
94424     } catch (std::out_of_range& e) {
94425       {
94426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94427       };
94428     } catch (std::exception& e) {
94429       {
94430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94431       };
94432     } catch (Dali::DaliException e) {
94433       {
94434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94435       };
94436     } catch (...) {
94437       {
94438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94439       };
94440     }
94441   }
94442
94443 }
94444
94445
94446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94447   void * jresult ;
94448   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94449   int arg2 ;
94450   int arg3 ;
94451   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94452
94453   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94454   arg2 = (int)jarg2;
94455   arg3 = (int)jarg3;
94456   {
94457     try {
94458       try {
94459         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);
94460       }
94461       catch(std::out_of_range &_e) {
94462         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94463         return 0;
94464       }
94465       catch(std::invalid_argument &_e) {
94466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94467         return 0;
94468       }
94469
94470     } catch (std::out_of_range& e) {
94471       {
94472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94473       };
94474     } catch (std::exception& e) {
94475       {
94476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94477       };
94478     } catch (Dali::DaliException e) {
94479       {
94480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94481       };
94482     } catch (...) {
94483       {
94484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94485       };
94486     }
94487   }
94488
94489   jresult = (void *)result;
94490   return jresult;
94491 }
94492
94493
94494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94495   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94496   int arg2 ;
94497   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94498
94499   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94500   arg2 = (int)jarg2;
94501   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94502   if (!arg3) {
94503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94504     return ;
94505   }
94506   {
94507     try {
94508       try {
94509         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);
94510       }
94511       catch(std::out_of_range &_e) {
94512         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94513         return ;
94514       }
94515
94516     } catch (std::out_of_range& e) {
94517       {
94518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94519       };
94520     } catch (std::exception& e) {
94521       {
94522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94523       };
94524     } catch (Dali::DaliException e) {
94525       {
94526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94527       };
94528     } catch (...) {
94529       {
94530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94531       };
94532     }
94533   }
94534
94535 }
94536
94537
94538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94539   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94540   int arg2 ;
94541   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94542
94543   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94544   arg2 = (int)jarg2;
94545   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94546   if (!arg3) {
94547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94548     return ;
94549   }
94550   {
94551     try {
94552       try {
94553         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);
94554       }
94555       catch(std::out_of_range &_e) {
94556         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94557         return ;
94558       }
94559
94560     } catch (std::out_of_range& e) {
94561       {
94562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94563       };
94564     } catch (std::exception& e) {
94565       {
94566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94567       };
94568     } catch (Dali::DaliException e) {
94569       {
94570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94571       };
94572     } catch (...) {
94573       {
94574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94575       };
94576     }
94577   }
94578
94579 }
94580
94581
94582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94583   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94584   int arg2 ;
94585
94586   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94587   arg2 = (int)jarg2;
94588   {
94589     try {
94590       try {
94591         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94592       }
94593       catch(std::out_of_range &_e) {
94594         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94595         return ;
94596       }
94597
94598     } catch (std::out_of_range& e) {
94599       {
94600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94601       };
94602     } catch (std::exception& e) {
94603       {
94604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94605       };
94606     } catch (Dali::DaliException e) {
94607       {
94608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94609       };
94610     } catch (...) {
94611       {
94612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94613       };
94614     }
94615   }
94616
94617 }
94618
94619
94620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94621   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94622   int arg2 ;
94623   int arg3 ;
94624
94625   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94626   arg2 = (int)jarg2;
94627   arg3 = (int)jarg3;
94628   {
94629     try {
94630       try {
94631         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94632       }
94633       catch(std::out_of_range &_e) {
94634         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94635         return ;
94636       }
94637       catch(std::invalid_argument &_e) {
94638         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94639         return ;
94640       }
94641
94642     } catch (std::out_of_range& e) {
94643       {
94644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94645       };
94646     } catch (std::exception& e) {
94647       {
94648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94649       };
94650     } catch (Dali::DaliException e) {
94651       {
94652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94653       };
94654     } catch (...) {
94655       {
94656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94657       };
94658     }
94659   }
94660
94661 }
94662
94663
94664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94665   void * jresult ;
94666   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94667   int arg2 ;
94668   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94669
94670   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94671   if (!arg1) {
94672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94673     return 0;
94674   }
94675   arg2 = (int)jarg2;
94676   {
94677     try {
94678       try {
94679         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);
94680       }
94681       catch(std::out_of_range &_e) {
94682         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94683         return 0;
94684       }
94685
94686     } catch (std::out_of_range& e) {
94687       {
94688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94689       };
94690     } catch (std::exception& e) {
94691       {
94692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94693       };
94694     } catch (Dali::DaliException e) {
94695       {
94696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94697       };
94698     } catch (...) {
94699       {
94700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94701       };
94702     }
94703   }
94704
94705   jresult = (void *)result;
94706   return jresult;
94707 }
94708
94709
94710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94711   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94712
94713   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94714   {
94715     try {
94716       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94717     } catch (std::out_of_range& e) {
94718       {
94719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94720       };
94721     } catch (std::exception& e) {
94722       {
94723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94724       };
94725     } catch (Dali::DaliException e) {
94726       {
94727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94728       };
94729     } catch (...) {
94730       {
94731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94732       };
94733     }
94734   }
94735
94736 }
94737
94738
94739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94740   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94741   int arg2 ;
94742   int arg3 ;
94743
94744   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94745   arg2 = (int)jarg2;
94746   arg3 = (int)jarg3;
94747   {
94748     try {
94749       try {
94750         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94751       }
94752       catch(std::out_of_range &_e) {
94753         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94754         return ;
94755       }
94756       catch(std::invalid_argument &_e) {
94757         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94758         return ;
94759       }
94760
94761     } catch (std::out_of_range& e) {
94762       {
94763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94764       };
94765     } catch (std::exception& e) {
94766       {
94767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94768       };
94769     } catch (Dali::DaliException e) {
94770       {
94771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94772       };
94773     } catch (...) {
94774       {
94775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94776       };
94777     }
94778   }
94779
94780 }
94781
94782
94783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94784   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94785   int arg2 ;
94786   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94787
94788   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94789   arg2 = (int)jarg2;
94790   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94791   if (!arg3) {
94792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94793     return ;
94794   }
94795   {
94796     try {
94797       try {
94798         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);
94799       }
94800       catch(std::out_of_range &_e) {
94801         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94802         return ;
94803       }
94804
94805     } catch (std::out_of_range& e) {
94806       {
94807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94808       };
94809     } catch (std::exception& e) {
94810       {
94811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94812       };
94813     } catch (Dali::DaliException e) {
94814       {
94815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94816       };
94817     } catch (...) {
94818       {
94819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94820       };
94821     }
94822   }
94823
94824 }
94825
94826
94827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94828   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94829
94830   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94831   {
94832     try {
94833       delete arg1;
94834     } catch (std::out_of_range& e) {
94835       {
94836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94837       };
94838     } catch (std::exception& e) {
94839       {
94840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94841       };
94842     } catch (Dali::DaliException e) {
94843       {
94844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94845       };
94846     } catch (...) {
94847       {
94848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94849       };
94850     }
94851   }
94852
94853 }
94854
94855
94856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94857   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94858
94859   arg1 = (std::vector< Dali::Actor > *)jarg1;
94860   {
94861     try {
94862       (arg1)->clear();
94863     } catch (std::out_of_range& e) {
94864       {
94865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94866       };
94867     } catch (std::exception& e) {
94868       {
94869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94870       };
94871     } catch (Dali::DaliException e) {
94872       {
94873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94874       };
94875     } catch (...) {
94876       {
94877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94878       };
94879     }
94880   }
94881
94882 }
94883
94884
94885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94886   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94887   Dali::Actor *arg2 = 0 ;
94888
94889   arg1 = (std::vector< Dali::Actor > *)jarg1;
94890   arg2 = (Dali::Actor *)jarg2;
94891   if (!arg2) {
94892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94893     return ;
94894   }
94895   {
94896     try {
94897       (arg1)->push_back((Dali::Actor const &)*arg2);
94898     } catch (std::out_of_range& e) {
94899       {
94900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94901       };
94902     } catch (std::exception& e) {
94903       {
94904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94905       };
94906     } catch (Dali::DaliException e) {
94907       {
94908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94909       };
94910     } catch (...) {
94911       {
94912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94913       };
94914     }
94915   }
94916
94917 }
94918
94919
94920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94921   unsigned long jresult ;
94922   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94923   std::vector< Dali::Actor >::size_type result;
94924
94925   arg1 = (std::vector< Dali::Actor > *)jarg1;
94926   {
94927     try {
94928       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94929     } catch (std::out_of_range& e) {
94930       {
94931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94932       };
94933     } catch (std::exception& e) {
94934       {
94935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94936       };
94937     } catch (Dali::DaliException e) {
94938       {
94939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94940       };
94941     } catch (...) {
94942       {
94943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94944       };
94945     }
94946   }
94947
94948   jresult = (unsigned long)result;
94949   return jresult;
94950 }
94951
94952
94953 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94954   unsigned long jresult ;
94955   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94956   std::vector< Dali::Actor >::size_type result;
94957
94958   arg1 = (std::vector< Dali::Actor > *)jarg1;
94959   {
94960     try {
94961       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94962     } catch (std::out_of_range& e) {
94963       {
94964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94965       };
94966     } catch (std::exception& e) {
94967       {
94968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94969       };
94970     } catch (Dali::DaliException e) {
94971       {
94972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94973       };
94974     } catch (...) {
94975       {
94976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94977       };
94978     }
94979   }
94980
94981   jresult = (unsigned long)result;
94982   return jresult;
94983 }
94984
94985
94986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94987   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94988   std::vector< Dali::Actor >::size_type arg2 ;
94989
94990   arg1 = (std::vector< Dali::Actor > *)jarg1;
94991   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94992   {
94993     try {
94994       (arg1)->reserve(arg2);
94995     } catch (std::out_of_range& e) {
94996       {
94997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94998       };
94999     } catch (std::exception& e) {
95000       {
95001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95002       };
95003     } catch (Dali::DaliException e) {
95004       {
95005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95006       };
95007     } catch (...) {
95008       {
95009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95010       };
95011     }
95012   }
95013
95014 }
95015
95016
95017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95018   void * jresult ;
95019   std::vector< Dali::Actor > *result = 0 ;
95020
95021   {
95022     try {
95023       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95024     } catch (std::out_of_range& e) {
95025       {
95026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95027       };
95028     } catch (std::exception& e) {
95029       {
95030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95031       };
95032     } catch (Dali::DaliException e) {
95033       {
95034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95035       };
95036     } catch (...) {
95037       {
95038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95039       };
95040     }
95041   }
95042
95043   jresult = (void *)result;
95044   return jresult;
95045 }
95046
95047
95048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95049   void * jresult ;
95050   std::vector< Dali::Actor > *arg1 = 0 ;
95051   std::vector< Dali::Actor > *result = 0 ;
95052
95053   arg1 = (std::vector< Dali::Actor > *)jarg1;
95054   if (!arg1) {
95055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95056     return 0;
95057   }
95058   {
95059     try {
95060       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95061     } catch (std::out_of_range& e) {
95062       {
95063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95064       };
95065     } catch (std::exception& e) {
95066       {
95067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95068       };
95069     } catch (Dali::DaliException e) {
95070       {
95071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95072       };
95073     } catch (...) {
95074       {
95075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95076       };
95077     }
95078   }
95079
95080   jresult = (void *)result;
95081   return jresult;
95082 }
95083
95084
95085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95086   void * jresult ;
95087   int arg1 ;
95088   std::vector< Dali::Actor > *result = 0 ;
95089
95090   arg1 = (int)jarg1;
95091   {
95092     try {
95093       try {
95094         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95095       }
95096       catch(std::out_of_range &_e) {
95097         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95098         return 0;
95099       }
95100
95101     } catch (std::out_of_range& e) {
95102       {
95103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95104       };
95105     } catch (std::exception& e) {
95106       {
95107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95108       };
95109     } catch (Dali::DaliException e) {
95110       {
95111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95112       };
95113     } catch (...) {
95114       {
95115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95116       };
95117     }
95118   }
95119
95120   jresult = (void *)result;
95121   return jresult;
95122 }
95123
95124
95125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95126   void * jresult ;
95127   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95128   int arg2 ;
95129   Dali::Actor result;
95130
95131   arg1 = (std::vector< Dali::Actor > *)jarg1;
95132   arg2 = (int)jarg2;
95133   {
95134     try {
95135       try {
95136         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95137       }
95138       catch(std::out_of_range &_e) {
95139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95140         return 0;
95141       }
95142
95143     } catch (std::out_of_range& e) {
95144       {
95145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95146       };
95147     } catch (std::exception& e) {
95148       {
95149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95150       };
95151     } catch (Dali::DaliException e) {
95152       {
95153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95154       };
95155     } catch (...) {
95156       {
95157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95158       };
95159     }
95160   }
95161
95162   jresult = new Dali::Actor((const Dali::Actor &)result);
95163   return jresult;
95164 }
95165
95166
95167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95168   void * jresult ;
95169   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95170   int arg2 ;
95171   Dali::Actor *result = 0 ;
95172
95173   arg1 = (std::vector< Dali::Actor > *)jarg1;
95174   arg2 = (int)jarg2;
95175   {
95176     try {
95177       try {
95178         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95179       }
95180       catch(std::out_of_range &_e) {
95181         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95182         return 0;
95183       }
95184
95185     } catch (std::out_of_range& e) {
95186       {
95187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95188       };
95189     } catch (std::exception& e) {
95190       {
95191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95192       };
95193     } catch (Dali::DaliException e) {
95194       {
95195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95196       };
95197     } catch (...) {
95198       {
95199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95200       };
95201     }
95202   }
95203
95204   jresult = (void *)result;
95205   return jresult;
95206 }
95207
95208
95209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95210   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95211   int arg2 ;
95212   Dali::Actor *arg3 = 0 ;
95213
95214   arg1 = (std::vector< Dali::Actor > *)jarg1;
95215   arg2 = (int)jarg2;
95216   arg3 = (Dali::Actor *)jarg3;
95217   if (!arg3) {
95218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95219     return ;
95220   }
95221   {
95222     try {
95223       try {
95224         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95225       }
95226       catch(std::out_of_range &_e) {
95227         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95228         return ;
95229       }
95230
95231     } catch (std::out_of_range& e) {
95232       {
95233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95234       };
95235     } catch (std::exception& e) {
95236       {
95237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95238       };
95239     } catch (Dali::DaliException e) {
95240       {
95241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95242       };
95243     } catch (...) {
95244       {
95245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95246       };
95247     }
95248   }
95249
95250 }
95251
95252
95253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95254   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95255   std::vector< Dali::Actor > *arg2 = 0 ;
95256
95257   arg1 = (std::vector< Dali::Actor > *)jarg1;
95258   arg2 = (std::vector< Dali::Actor > *)jarg2;
95259   if (!arg2) {
95260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95261     return ;
95262   }
95263   {
95264     try {
95265       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95266     } catch (std::out_of_range& e) {
95267       {
95268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95269       };
95270     } catch (std::exception& e) {
95271       {
95272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95273       };
95274     } catch (Dali::DaliException e) {
95275       {
95276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95277       };
95278     } catch (...) {
95279       {
95280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95281       };
95282     }
95283   }
95284
95285 }
95286
95287
95288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95289   void * jresult ;
95290   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95291   int arg2 ;
95292   int arg3 ;
95293   std::vector< Dali::Actor > *result = 0 ;
95294
95295   arg1 = (std::vector< Dali::Actor > *)jarg1;
95296   arg2 = (int)jarg2;
95297   arg3 = (int)jarg3;
95298   {
95299     try {
95300       try {
95301         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95302       }
95303       catch(std::out_of_range &_e) {
95304         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95305         return 0;
95306       }
95307       catch(std::invalid_argument &_e) {
95308         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95309         return 0;
95310       }
95311
95312     } catch (std::out_of_range& e) {
95313       {
95314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95315       };
95316     } catch (std::exception& e) {
95317       {
95318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95319       };
95320     } catch (Dali::DaliException e) {
95321       {
95322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95323       };
95324     } catch (...) {
95325       {
95326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95327       };
95328     }
95329   }
95330
95331   jresult = (void *)result;
95332   return jresult;
95333 }
95334
95335
95336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95337   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95338   int arg2 ;
95339   Dali::Actor *arg3 = 0 ;
95340
95341   arg1 = (std::vector< Dali::Actor > *)jarg1;
95342   arg2 = (int)jarg2;
95343   arg3 = (Dali::Actor *)jarg3;
95344   if (!arg3) {
95345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95346     return ;
95347   }
95348   {
95349     try {
95350       try {
95351         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95352       }
95353       catch(std::out_of_range &_e) {
95354         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95355         return ;
95356       }
95357
95358     } catch (std::out_of_range& e) {
95359       {
95360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95361       };
95362     } catch (std::exception& e) {
95363       {
95364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95365       };
95366     } catch (Dali::DaliException e) {
95367       {
95368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95369       };
95370     } catch (...) {
95371       {
95372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95373       };
95374     }
95375   }
95376
95377 }
95378
95379
95380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95381   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95382   int arg2 ;
95383   std::vector< Dali::Actor > *arg3 = 0 ;
95384
95385   arg1 = (std::vector< Dali::Actor > *)jarg1;
95386   arg2 = (int)jarg2;
95387   arg3 = (std::vector< Dali::Actor > *)jarg3;
95388   if (!arg3) {
95389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95390     return ;
95391   }
95392   {
95393     try {
95394       try {
95395         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95396       }
95397       catch(std::out_of_range &_e) {
95398         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95399         return ;
95400       }
95401
95402     } catch (std::out_of_range& e) {
95403       {
95404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95405       };
95406     } catch (std::exception& e) {
95407       {
95408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95409       };
95410     } catch (Dali::DaliException e) {
95411       {
95412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95413       };
95414     } catch (...) {
95415       {
95416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95417       };
95418     }
95419   }
95420
95421 }
95422
95423
95424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95425   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95426   int arg2 ;
95427
95428   arg1 = (std::vector< Dali::Actor > *)jarg1;
95429   arg2 = (int)jarg2;
95430   {
95431     try {
95432       try {
95433         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95434       }
95435       catch(std::out_of_range &_e) {
95436         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95437         return ;
95438       }
95439
95440     } catch (std::out_of_range& e) {
95441       {
95442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95443       };
95444     } catch (std::exception& e) {
95445       {
95446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95447       };
95448     } catch (Dali::DaliException e) {
95449       {
95450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95451       };
95452     } catch (...) {
95453       {
95454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95455       };
95456     }
95457   }
95458
95459 }
95460
95461
95462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95463   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95464   int arg2 ;
95465   int arg3 ;
95466
95467   arg1 = (std::vector< Dali::Actor > *)jarg1;
95468   arg2 = (int)jarg2;
95469   arg3 = (int)jarg3;
95470   {
95471     try {
95472       try {
95473         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95474       }
95475       catch(std::out_of_range &_e) {
95476         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95477         return ;
95478       }
95479       catch(std::invalid_argument &_e) {
95480         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95481         return ;
95482       }
95483
95484     } catch (std::out_of_range& e) {
95485       {
95486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95487       };
95488     } catch (std::exception& e) {
95489       {
95490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95491       };
95492     } catch (Dali::DaliException e) {
95493       {
95494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95495       };
95496     } catch (...) {
95497       {
95498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95499       };
95500     }
95501   }
95502
95503 }
95504
95505
95506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95507   void * jresult ;
95508   Dali::Actor *arg1 = 0 ;
95509   int arg2 ;
95510   std::vector< Dali::Actor > *result = 0 ;
95511
95512   arg1 = (Dali::Actor *)jarg1;
95513   if (!arg1) {
95514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95515     return 0;
95516   }
95517   arg2 = (int)jarg2;
95518   {
95519     try {
95520       try {
95521         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95522       }
95523       catch(std::out_of_range &_e) {
95524         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95525         return 0;
95526       }
95527
95528     } catch (std::out_of_range& e) {
95529       {
95530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95531       };
95532     } catch (std::exception& e) {
95533       {
95534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95535       };
95536     } catch (Dali::DaliException e) {
95537       {
95538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95539       };
95540     } catch (...) {
95541       {
95542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95543       };
95544     }
95545   }
95546
95547   jresult = (void *)result;
95548   return jresult;
95549 }
95550
95551
95552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95553   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95554
95555   arg1 = (std::vector< Dali::Actor > *)jarg1;
95556   {
95557     try {
95558       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95559     } catch (std::out_of_range& e) {
95560       {
95561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95562       };
95563     } catch (std::exception& e) {
95564       {
95565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95566       };
95567     } catch (Dali::DaliException e) {
95568       {
95569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95570       };
95571     } catch (...) {
95572       {
95573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95574       };
95575     }
95576   }
95577
95578 }
95579
95580
95581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95582   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95583   int arg2 ;
95584   int arg3 ;
95585
95586   arg1 = (std::vector< Dali::Actor > *)jarg1;
95587   arg2 = (int)jarg2;
95588   arg3 = (int)jarg3;
95589   {
95590     try {
95591       try {
95592         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95593       }
95594       catch(std::out_of_range &_e) {
95595         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95596         return ;
95597       }
95598       catch(std::invalid_argument &_e) {
95599         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95600         return ;
95601       }
95602
95603     } catch (std::out_of_range& e) {
95604       {
95605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95606       };
95607     } catch (std::exception& e) {
95608       {
95609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95610       };
95611     } catch (Dali::DaliException e) {
95612       {
95613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95614       };
95615     } catch (...) {
95616       {
95617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95618       };
95619     }
95620   }
95621
95622 }
95623
95624
95625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95626   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95627   int arg2 ;
95628   std::vector< Dali::Actor > *arg3 = 0 ;
95629
95630   arg1 = (std::vector< Dali::Actor > *)jarg1;
95631   arg2 = (int)jarg2;
95632   arg3 = (std::vector< Dali::Actor > *)jarg3;
95633   if (!arg3) {
95634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95635     return ;
95636   }
95637   {
95638     try {
95639       try {
95640         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95641       }
95642       catch(std::out_of_range &_e) {
95643         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95644         return ;
95645       }
95646
95647     } catch (std::out_of_range& e) {
95648       {
95649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95650       };
95651     } catch (std::exception& e) {
95652       {
95653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95654       };
95655     } catch (Dali::DaliException e) {
95656       {
95657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95658       };
95659     } catch (...) {
95660       {
95661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95662       };
95663     }
95664   }
95665
95666 }
95667
95668
95669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95670   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95671
95672   arg1 = (std::vector< Dali::Actor > *)jarg1;
95673   {
95674     try {
95675       delete arg1;
95676     } catch (std::out_of_range& e) {
95677       {
95678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95679       };
95680     } catch (std::exception& e) {
95681       {
95682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95683       };
95684     } catch (Dali::DaliException e) {
95685       {
95686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95687       };
95688     } catch (...) {
95689       {
95690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95691       };
95692     }
95693   }
95694
95695 }
95696
95697
95698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95699   unsigned int jresult ;
95700   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95701   bool result;
95702
95703   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95704   {
95705     try {
95706       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95707     } catch (std::out_of_range& e) {
95708       {
95709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95710       };
95711     } catch (std::exception& e) {
95712       {
95713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95714       };
95715     } catch (Dali::DaliException e) {
95716       {
95717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95718       };
95719     } catch (...) {
95720       {
95721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95722       };
95723     }
95724   }
95725
95726   jresult = result;
95727   return jresult;
95728 }
95729
95730
95731 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95732   unsigned long jresult ;
95733   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95734   std::size_t result;
95735
95736   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95737   {
95738     try {
95739       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95740     } catch (std::out_of_range& e) {
95741       {
95742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95743       };
95744     } catch (std::exception& e) {
95745       {
95746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95747       };
95748     } catch (Dali::DaliException e) {
95749       {
95750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95751       };
95752     } catch (...) {
95753       {
95754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95755       };
95756     }
95757   }
95758
95759   jresult = (unsigned long)result;
95760   return jresult;
95761 }
95762
95763
95764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95765   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95766   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95767
95768   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95769   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95770   {
95771     try {
95772       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95773     } catch (std::out_of_range& e) {
95774       {
95775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95776       };
95777     } catch (std::exception& e) {
95778       {
95779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95780       };
95781     } catch (Dali::DaliException e) {
95782       {
95783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95784       };
95785     } catch (...) {
95786       {
95787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95788       };
95789     }
95790   }
95791
95792 }
95793
95794
95795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95796   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95797   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95798
95799   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95800   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95801   {
95802     try {
95803       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95804     } catch (std::out_of_range& e) {
95805       {
95806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95807       };
95808     } catch (std::exception& e) {
95809       {
95810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95811       };
95812     } catch (Dali::DaliException e) {
95813       {
95814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95815       };
95816     } catch (...) {
95817       {
95818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95819       };
95820     }
95821   }
95822
95823 }
95824
95825
95826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95827   unsigned int jresult ;
95828   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95829   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95830   bool result;
95831
95832   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95833   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95834   if (!arg2) {
95835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95836     return 0;
95837   }
95838   {
95839     try {
95840       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95841     } catch (std::out_of_range& e) {
95842       {
95843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95844       };
95845     } catch (std::exception& e) {
95846       {
95847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95848       };
95849     } catch (Dali::DaliException e) {
95850       {
95851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95852       };
95853     } catch (...) {
95854       {
95855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95856       };
95857     }
95858   }
95859
95860   jresult = result;
95861   return jresult;
95862 }
95863
95864
95865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95866   void * jresult ;
95867   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95868
95869   {
95870     try {
95871       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95872     } catch (std::out_of_range& e) {
95873       {
95874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95875       };
95876     } catch (std::exception& e) {
95877       {
95878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95879       };
95880     } catch (Dali::DaliException e) {
95881       {
95882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95883       };
95884     } catch (...) {
95885       {
95886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95887       };
95888     }
95889   }
95890
95891   jresult = (void *)result;
95892   return jresult;
95893 }
95894
95895
95896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95897   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95898
95899   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95900   {
95901     try {
95902       delete arg1;
95903     } catch (std::out_of_range& e) {
95904       {
95905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95906       };
95907     } catch (std::exception& e) {
95908       {
95909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95910       };
95911     } catch (Dali::DaliException e) {
95912       {
95913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95914       };
95915     } catch (...) {
95916       {
95917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95918       };
95919     }
95920   }
95921
95922 }
95923
95924
95925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95926   unsigned int jresult ;
95927   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95928   bool result;
95929
95930   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95931   {
95932     try {
95933       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);
95934     } catch (std::out_of_range& e) {
95935       {
95936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95937       };
95938     } catch (std::exception& e) {
95939       {
95940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95941       };
95942     } catch (Dali::DaliException e) {
95943       {
95944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95945       };
95946     } catch (...) {
95947       {
95948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95949       };
95950     }
95951   }
95952
95953   jresult = result;
95954   return jresult;
95955 }
95956
95957
95958 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95959   unsigned long jresult ;
95960   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95961   std::size_t result;
95962
95963   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95964   {
95965     try {
95966       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);
95967     } catch (std::out_of_range& e) {
95968       {
95969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95970       };
95971     } catch (std::exception& e) {
95972       {
95973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95974       };
95975     } catch (Dali::DaliException e) {
95976       {
95977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95978       };
95979     } catch (...) {
95980       {
95981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95982       };
95983     }
95984   }
95985
95986   jresult = (unsigned long)result;
95987   return jresult;
95988 }
95989
95990
95991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95992   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95993   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95994
95995   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95996   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95997   {
95998     try {
95999       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
96000     } catch (std::out_of_range& e) {
96001       {
96002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96003       };
96004     } catch (std::exception& e) {
96005       {
96006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96007       };
96008     } catch (Dali::DaliException e) {
96009       {
96010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96011       };
96012     } catch (...) {
96013       {
96014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96015       };
96016     }
96017   }
96018
96019 }
96020
96021
96022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96023   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96024   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96025
96026   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96027   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96028   {
96029     try {
96030       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96031     } catch (std::out_of_range& e) {
96032       {
96033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96034       };
96035     } catch (std::exception& e) {
96036       {
96037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96038       };
96039     } catch (Dali::DaliException e) {
96040       {
96041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96042       };
96043     } catch (...) {
96044       {
96045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96046       };
96047     }
96048   }
96049
96050 }
96051
96052
96053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96054   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96055   Dali::Actor arg2 ;
96056   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96057   Dali::Actor *argp2 ;
96058
96059   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96060   argp2 = (Dali::Actor *)jarg2;
96061   if (!argp2) {
96062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96063     return ;
96064   }
96065   arg2 = *argp2;
96066   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96067   {
96068     try {
96069       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96070     } catch (std::out_of_range& e) {
96071       {
96072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96073       };
96074     } catch (std::exception& e) {
96075       {
96076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96077       };
96078     } catch (Dali::DaliException e) {
96079       {
96080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96081       };
96082     } catch (...) {
96083       {
96084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96085       };
96086     }
96087   }
96088
96089 }
96090
96091
96092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96093   void * jresult ;
96094   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96095
96096   {
96097     try {
96098       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96099     } catch (std::out_of_range& e) {
96100       {
96101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96102       };
96103     } catch (std::exception& e) {
96104       {
96105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96106       };
96107     } catch (Dali::DaliException e) {
96108       {
96109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96110       };
96111     } catch (...) {
96112       {
96113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96114       };
96115     }
96116   }
96117
96118   jresult = (void *)result;
96119   return jresult;
96120 }
96121
96122
96123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96124   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96125
96126   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96127   {
96128     try {
96129       delete arg1;
96130     } catch (std::out_of_range& e) {
96131       {
96132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96133       };
96134     } catch (std::exception& e) {
96135       {
96136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96137       };
96138     } catch (Dali::DaliException e) {
96139       {
96140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96141       };
96142     } catch (...) {
96143       {
96144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96145       };
96146     }
96147   }
96148
96149 }
96150
96151
96152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96153   unsigned int jresult ;
96154   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96155   bool result;
96156
96157   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96158   {
96159     try {
96160       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96161     } catch (std::out_of_range& e) {
96162       {
96163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96164       };
96165     } catch (std::exception& e) {
96166       {
96167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96168       };
96169     } catch (Dali::DaliException e) {
96170       {
96171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96172       };
96173     } catch (...) {
96174       {
96175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96176       };
96177     }
96178   }
96179
96180   jresult = result;
96181   return jresult;
96182 }
96183
96184
96185 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96186   unsigned long jresult ;
96187   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96188   std::size_t result;
96189
96190   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96191   {
96192     try {
96193       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96194     } catch (std::out_of_range& e) {
96195       {
96196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96197       };
96198     } catch (std::exception& e) {
96199       {
96200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96201       };
96202     } catch (Dali::DaliException e) {
96203       {
96204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96205       };
96206     } catch (...) {
96207       {
96208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96209       };
96210     }
96211   }
96212
96213   jresult = (unsigned long)result;
96214   return jresult;
96215 }
96216
96217
96218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96219   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96220   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96221
96222   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96223   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96224   {
96225     try {
96226       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96227     } catch (std::out_of_range& e) {
96228       {
96229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96230       };
96231     } catch (std::exception& e) {
96232       {
96233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96234       };
96235     } catch (Dali::DaliException e) {
96236       {
96237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96238       };
96239     } catch (...) {
96240       {
96241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96242       };
96243     }
96244   }
96245
96246 }
96247
96248
96249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96250   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96251   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96252
96253   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96254   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96255   {
96256     try {
96257       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96258     } catch (std::out_of_range& e) {
96259       {
96260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96261       };
96262     } catch (std::exception& e) {
96263       {
96264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96265       };
96266     } catch (Dali::DaliException e) {
96267       {
96268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96269       };
96270     } catch (...) {
96271       {
96272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96273       };
96274     }
96275   }
96276
96277 }
96278
96279
96280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96281   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96282   Dali::Actor arg2 ;
96283   Dali::Actor arg3 ;
96284   Dali::Actor *argp2 ;
96285   Dali::Actor *argp3 ;
96286
96287   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96288   argp2 = (Dali::Actor *)jarg2;
96289   if (!argp2) {
96290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96291     return ;
96292   }
96293   arg2 = *argp2;
96294   argp3 = (Dali::Actor *)jarg3;
96295   if (!argp3) {
96296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96297     return ;
96298   }
96299   arg3 = *argp3;
96300   {
96301     try {
96302       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96303     } catch (std::out_of_range& e) {
96304       {
96305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96306       };
96307     } catch (std::exception& e) {
96308       {
96309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96310       };
96311     } catch (Dali::DaliException e) {
96312       {
96313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96314       };
96315     } catch (...) {
96316       {
96317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96318       };
96319     }
96320   }
96321
96322 }
96323
96324
96325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96326   void * jresult ;
96327   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96328
96329   {
96330     try {
96331       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96332     } catch (std::out_of_range& e) {
96333       {
96334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96335       };
96336     } catch (std::exception& e) {
96337       {
96338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96339       };
96340     } catch (Dali::DaliException e) {
96341       {
96342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96343       };
96344     } catch (...) {
96345       {
96346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96347       };
96348     }
96349   }
96350
96351   jresult = (void *)result;
96352   return jresult;
96353 }
96354
96355
96356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96357   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96358
96359   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96360   {
96361     try {
96362       delete arg1;
96363     } catch (std::out_of_range& e) {
96364       {
96365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96366       };
96367     } catch (std::exception& e) {
96368       {
96369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96370       };
96371     } catch (Dali::DaliException e) {
96372       {
96373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96374       };
96375     } catch (...) {
96376       {
96377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96378       };
96379     }
96380   }
96381
96382 }
96383
96384
96385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96386   unsigned int jresult ;
96387   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96388   bool result;
96389
96390   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96391   {
96392     try {
96393       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96394     } catch (std::out_of_range& e) {
96395       {
96396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96397       };
96398     } catch (std::exception& e) {
96399       {
96400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96401       };
96402     } catch (Dali::DaliException e) {
96403       {
96404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96405       };
96406     } catch (...) {
96407       {
96408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96409       };
96410     }
96411   }
96412
96413   jresult = result;
96414   return jresult;
96415 }
96416
96417
96418 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96419   unsigned long jresult ;
96420   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96421   std::size_t result;
96422
96423   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96424   {
96425     try {
96426       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96427     } catch (std::out_of_range& e) {
96428       {
96429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96430       };
96431     } catch (std::exception& e) {
96432       {
96433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96434       };
96435     } catch (Dali::DaliException e) {
96436       {
96437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96438       };
96439     } catch (...) {
96440       {
96441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96442       };
96443     }
96444   }
96445
96446   jresult = (unsigned long)result;
96447   return jresult;
96448 }
96449
96450
96451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96452   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96453   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96454
96455   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96456   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96457   {
96458     try {
96459       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96460     } catch (std::out_of_range& e) {
96461       {
96462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96463       };
96464     } catch (std::exception& e) {
96465       {
96466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96467       };
96468     } catch (Dali::DaliException e) {
96469       {
96470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96471       };
96472     } catch (...) {
96473       {
96474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96475       };
96476     }
96477   }
96478
96479 }
96480
96481
96482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96483   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96484   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96485
96486   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96487   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96488   {
96489     try {
96490       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96491     } catch (std::out_of_range& e) {
96492       {
96493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96494       };
96495     } catch (std::exception& e) {
96496       {
96497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96498       };
96499     } catch (Dali::DaliException e) {
96500       {
96501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96502       };
96503     } catch (...) {
96504       {
96505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96506       };
96507     }
96508   }
96509
96510 }
96511
96512
96513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96514   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96515   Dali::Actor arg2 ;
96516   bool arg3 ;
96517   Dali::Actor *argp2 ;
96518
96519   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96520   argp2 = (Dali::Actor *)jarg2;
96521   if (!argp2) {
96522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96523     return ;
96524   }
96525   arg2 = *argp2;
96526   arg3 = jarg3 ? true : false;
96527   {
96528     try {
96529       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96530     } catch (std::out_of_range& e) {
96531       {
96532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96533       };
96534     } catch (std::exception& e) {
96535       {
96536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96537       };
96538     } catch (Dali::DaliException e) {
96539       {
96540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96541       };
96542     } catch (...) {
96543       {
96544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96545       };
96546     }
96547   }
96548
96549 }
96550
96551
96552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96553   void * jresult ;
96554   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96555
96556   {
96557     try {
96558       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96559     } catch (std::out_of_range& e) {
96560       {
96561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96562       };
96563     } catch (std::exception& e) {
96564       {
96565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96566       };
96567     } catch (Dali::DaliException e) {
96568       {
96569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96570       };
96571     } catch (...) {
96572       {
96573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96574       };
96575     }
96576   }
96577
96578   jresult = (void *)result;
96579   return jresult;
96580 }
96581
96582
96583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96584   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96585
96586   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96587   {
96588     try {
96589       delete arg1;
96590     } catch (std::out_of_range& e) {
96591       {
96592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96593       };
96594     } catch (std::exception& e) {
96595       {
96596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96597       };
96598     } catch (Dali::DaliException e) {
96599       {
96600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96601       };
96602     } catch (...) {
96603       {
96604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96605       };
96606     }
96607   }
96608
96609 }
96610
96611
96612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96613   unsigned int jresult ;
96614   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96615   bool result;
96616
96617   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96618   {
96619     try {
96620       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);
96621     } catch (std::out_of_range& e) {
96622       {
96623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96624       };
96625     } catch (std::exception& e) {
96626       {
96627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96628       };
96629     } catch (Dali::DaliException e) {
96630       {
96631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96632       };
96633     } catch (...) {
96634       {
96635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96636       };
96637     }
96638   }
96639
96640   jresult = result;
96641   return jresult;
96642 }
96643
96644
96645 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96646   unsigned long jresult ;
96647   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96648   std::size_t result;
96649
96650   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96651   {
96652     try {
96653       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);
96654     } catch (std::out_of_range& e) {
96655       {
96656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96657       };
96658     } catch (std::exception& e) {
96659       {
96660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96661       };
96662     } catch (Dali::DaliException e) {
96663       {
96664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96665       };
96666     } catch (...) {
96667       {
96668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96669       };
96670     }
96671   }
96672
96673   jresult = (unsigned long)result;
96674   return jresult;
96675 }
96676
96677
96678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96679   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96680   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96681
96682   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96683   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96684   {
96685     try {
96686       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96687     } catch (std::out_of_range& e) {
96688       {
96689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96690       };
96691     } catch (std::exception& e) {
96692       {
96693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96694       };
96695     } catch (Dali::DaliException e) {
96696       {
96697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96698       };
96699     } catch (...) {
96700       {
96701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96702       };
96703     }
96704   }
96705
96706 }
96707
96708
96709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96710   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96711   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96712
96713   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96714   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96715   {
96716     try {
96717       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96718     } catch (std::out_of_range& e) {
96719       {
96720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96721       };
96722     } catch (std::exception& e) {
96723       {
96724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96725       };
96726     } catch (Dali::DaliException e) {
96727       {
96728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96729       };
96730     } catch (...) {
96731       {
96732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96733       };
96734     }
96735   }
96736
96737 }
96738
96739
96740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96741   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96742   Dali::Toolkit::StyleManager arg2 ;
96743   Dali::StyleChange::Type arg3 ;
96744   Dali::Toolkit::StyleManager *argp2 ;
96745
96746   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96747   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96748   if (!argp2) {
96749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96750     return ;
96751   }
96752   arg2 = *argp2;
96753   arg3 = (Dali::StyleChange::Type)jarg3;
96754   {
96755     try {
96756       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96757     } catch (std::out_of_range& e) {
96758       {
96759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96760       };
96761     } catch (std::exception& e) {
96762       {
96763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96764       };
96765     } catch (Dali::DaliException e) {
96766       {
96767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96768       };
96769     } catch (...) {
96770       {
96771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96772       };
96773     }
96774   }
96775
96776 }
96777
96778
96779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96780   void * jresult ;
96781   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96782
96783   {
96784     try {
96785       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96786     } catch (std::out_of_range& e) {
96787       {
96788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96789       };
96790     } catch (std::exception& e) {
96791       {
96792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96793       };
96794     } catch (Dali::DaliException e) {
96795       {
96796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96797       };
96798     } catch (...) {
96799       {
96800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96801       };
96802     }
96803   }
96804
96805   jresult = (void *)result;
96806   return jresult;
96807 }
96808
96809
96810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96811   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96812
96813   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96814   {
96815     try {
96816       delete arg1;
96817     } catch (std::out_of_range& e) {
96818       {
96819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96820       };
96821     } catch (std::exception& e) {
96822       {
96823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96824       };
96825     } catch (Dali::DaliException e) {
96826       {
96827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96828       };
96829     } catch (...) {
96830       {
96831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96832       };
96833     }
96834   }
96835
96836 }
96837
96838
96839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96840   unsigned int jresult ;
96841   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96842   bool result;
96843
96844   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96845   {
96846     try {
96847       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96848     } catch (std::out_of_range& e) {
96849       {
96850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96851       };
96852     } catch (std::exception& e) {
96853       {
96854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96855       };
96856     } catch (Dali::DaliException e) {
96857       {
96858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96859       };
96860     } catch (...) {
96861       {
96862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96863       };
96864     }
96865   }
96866
96867   jresult = result;
96868   return jresult;
96869 }
96870
96871
96872 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96873   unsigned long jresult ;
96874   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96875   std::size_t result;
96876
96877   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96878   {
96879     try {
96880       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96881     } catch (std::out_of_range& e) {
96882       {
96883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96884       };
96885     } catch (std::exception& e) {
96886       {
96887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96888       };
96889     } catch (Dali::DaliException e) {
96890       {
96891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96892       };
96893     } catch (...) {
96894       {
96895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96896       };
96897     }
96898   }
96899
96900   jresult = (unsigned long)result;
96901   return jresult;
96902 }
96903
96904
96905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96906   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96907   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96908
96909   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96910   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96911   {
96912     try {
96913       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96914     } catch (std::out_of_range& e) {
96915       {
96916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96917       };
96918     } catch (std::exception& e) {
96919       {
96920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96921       };
96922     } catch (Dali::DaliException e) {
96923       {
96924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96925       };
96926     } catch (...) {
96927       {
96928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96929       };
96930     }
96931   }
96932
96933 }
96934
96935
96936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96937   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96938   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96939
96940   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96941   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96942   {
96943     try {
96944       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96945     } catch (std::out_of_range& e) {
96946       {
96947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96948       };
96949     } catch (std::exception& e) {
96950       {
96951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96952       };
96953     } catch (Dali::DaliException e) {
96954       {
96955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96956       };
96957     } catch (...) {
96958       {
96959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96960       };
96961     }
96962   }
96963
96964 }
96965
96966
96967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96968   unsigned int jresult ;
96969   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96970   Dali::Toolkit::Button arg2 ;
96971   Dali::Toolkit::Button *argp2 ;
96972   bool result;
96973
96974   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96975   argp2 = (Dali::Toolkit::Button *)jarg2;
96976   if (!argp2) {
96977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96978     return 0;
96979   }
96980   arg2 = *argp2;
96981   {
96982     try {
96983       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96984     } catch (std::out_of_range& e) {
96985       {
96986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96987       };
96988     } catch (std::exception& e) {
96989       {
96990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96991       };
96992     } catch (Dali::DaliException e) {
96993       {
96994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96995       };
96996     } catch (...) {
96997       {
96998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96999       };
97000     }
97001   }
97002
97003   jresult = result;
97004   return jresult;
97005 }
97006
97007
97008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
97009   void * jresult ;
97010   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
97011
97012   {
97013     try {
97014       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97015     } catch (std::out_of_range& e) {
97016       {
97017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97018       };
97019     } catch (std::exception& e) {
97020       {
97021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97022       };
97023     } catch (Dali::DaliException e) {
97024       {
97025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97026       };
97027     } catch (...) {
97028       {
97029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97030       };
97031     }
97032   }
97033
97034   jresult = (void *)result;
97035   return jresult;
97036 }
97037
97038
97039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97040   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97041
97042   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97043   {
97044     try {
97045       delete arg1;
97046     } catch (std::out_of_range& e) {
97047       {
97048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97049       };
97050     } catch (std::exception& e) {
97051       {
97052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97053       };
97054     } catch (Dali::DaliException e) {
97055       {
97056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97057       };
97058     } catch (...) {
97059       {
97060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97061       };
97062     }
97063   }
97064
97065 }
97066
97067
97068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97069   unsigned int jresult ;
97070   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97071   bool result;
97072
97073   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97074   {
97075     try {
97076       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97077     } catch (std::out_of_range& e) {
97078       {
97079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97080       };
97081     } catch (std::exception& e) {
97082       {
97083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97084       };
97085     } catch (Dali::DaliException e) {
97086       {
97087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97088       };
97089     } catch (...) {
97090       {
97091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97092       };
97093     }
97094   }
97095
97096   jresult = result;
97097   return jresult;
97098 }
97099
97100
97101 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97102   unsigned long jresult ;
97103   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97104   std::size_t result;
97105
97106   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97107   {
97108     try {
97109       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97110     } catch (std::out_of_range& e) {
97111       {
97112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97113       };
97114     } catch (std::exception& e) {
97115       {
97116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97117       };
97118     } catch (Dali::DaliException e) {
97119       {
97120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97121       };
97122     } catch (...) {
97123       {
97124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97125       };
97126     }
97127   }
97128
97129   jresult = (unsigned long)result;
97130   return jresult;
97131 }
97132
97133
97134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97135   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97136   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97137
97138   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97139   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97140   {
97141     try {
97142       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97143     } catch (std::out_of_range& e) {
97144       {
97145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97146       };
97147     } catch (std::exception& e) {
97148       {
97149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97150       };
97151     } catch (Dali::DaliException e) {
97152       {
97153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97154       };
97155     } catch (...) {
97156       {
97157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97158       };
97159     }
97160   }
97161
97162 }
97163
97164
97165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97166   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97167   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97168
97169   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97170   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97171   {
97172     try {
97173       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97174     } catch (std::out_of_range& e) {
97175       {
97176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97177       };
97178     } catch (std::exception& e) {
97179       {
97180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97181       };
97182     } catch (Dali::DaliException e) {
97183       {
97184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97185       };
97186     } catch (...) {
97187       {
97188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97189       };
97190     }
97191   }
97192
97193 }
97194
97195
97196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97197   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97198   Dali::Toolkit::GaussianBlurView arg2 ;
97199   Dali::Toolkit::GaussianBlurView *argp2 ;
97200
97201   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97202   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97203   if (!argp2) {
97204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97205     return ;
97206   }
97207   arg2 = *argp2;
97208   {
97209     try {
97210       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97211     } catch (std::out_of_range& e) {
97212       {
97213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97214       };
97215     } catch (std::exception& e) {
97216       {
97217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97218       };
97219     } catch (Dali::DaliException e) {
97220       {
97221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97222       };
97223     } catch (...) {
97224       {
97225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97226       };
97227     }
97228   }
97229
97230 }
97231
97232
97233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97234   void * jresult ;
97235   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97236
97237   {
97238     try {
97239       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97240     } catch (std::out_of_range& e) {
97241       {
97242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97243       };
97244     } catch (std::exception& e) {
97245       {
97246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97247       };
97248     } catch (Dali::DaliException e) {
97249       {
97250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97251       };
97252     } catch (...) {
97253       {
97254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97255       };
97256     }
97257   }
97258
97259   jresult = (void *)result;
97260   return jresult;
97261 }
97262
97263
97264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97265   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97266
97267   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97268   {
97269     try {
97270       delete arg1;
97271     } catch (std::out_of_range& e) {
97272       {
97273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97274       };
97275     } catch (std::exception& e) {
97276       {
97277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97278       };
97279     } catch (Dali::DaliException e) {
97280       {
97281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97282       };
97283     } catch (...) {
97284       {
97285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97286       };
97287     }
97288   }
97289
97290 }
97291
97292
97293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97294   unsigned int jresult ;
97295   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97296   bool result;
97297
97298   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97299   {
97300     try {
97301       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);
97302     } catch (std::out_of_range& e) {
97303       {
97304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97305       };
97306     } catch (std::exception& e) {
97307       {
97308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97309       };
97310     } catch (Dali::DaliException e) {
97311       {
97312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97313       };
97314     } catch (...) {
97315       {
97316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97317       };
97318     }
97319   }
97320
97321   jresult = result;
97322   return jresult;
97323 }
97324
97325
97326 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97327   unsigned long jresult ;
97328   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97329   std::size_t result;
97330
97331   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97332   {
97333     try {
97334       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);
97335     } catch (std::out_of_range& e) {
97336       {
97337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97338       };
97339     } catch (std::exception& e) {
97340       {
97341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97342       };
97343     } catch (Dali::DaliException e) {
97344       {
97345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97346       };
97347     } catch (...) {
97348       {
97349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97350       };
97351     }
97352   }
97353
97354   jresult = (unsigned long)result;
97355   return jresult;
97356 }
97357
97358
97359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97360   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97361   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97362
97363   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97364   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97365   {
97366     try {
97367       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97368     } catch (std::out_of_range& e) {
97369       {
97370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97371       };
97372     } catch (std::exception& e) {
97373       {
97374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97375       };
97376     } catch (Dali::DaliException e) {
97377       {
97378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97379       };
97380     } catch (...) {
97381       {
97382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97383       };
97384     }
97385   }
97386
97387 }
97388
97389
97390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97391   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97392   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97393
97394   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97395   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97396   {
97397     try {
97398       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97399     } catch (std::out_of_range& e) {
97400       {
97401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97402       };
97403     } catch (std::exception& e) {
97404       {
97405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97406       };
97407     } catch (Dali::DaliException e) {
97408       {
97409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97410       };
97411     } catch (...) {
97412       {
97413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97414       };
97415     }
97416   }
97417
97418 }
97419
97420
97421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97422   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97423   Dali::Toolkit::PageTurnView arg2 ;
97424   unsigned int arg3 ;
97425   bool arg4 ;
97426   Dali::Toolkit::PageTurnView *argp2 ;
97427
97428   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97429   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97430   if (!argp2) {
97431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97432     return ;
97433   }
97434   arg2 = *argp2;
97435   arg3 = (unsigned int)jarg3;
97436   arg4 = jarg4 ? true : false;
97437   {
97438     try {
97439       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97440     } catch (std::out_of_range& e) {
97441       {
97442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97443       };
97444     } catch (std::exception& e) {
97445       {
97446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97447       };
97448     } catch (Dali::DaliException e) {
97449       {
97450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97451       };
97452     } catch (...) {
97453       {
97454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97455       };
97456     }
97457   }
97458
97459 }
97460
97461
97462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97463   void * jresult ;
97464   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97465
97466   {
97467     try {
97468       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97469     } catch (std::out_of_range& e) {
97470       {
97471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97472       };
97473     } catch (std::exception& e) {
97474       {
97475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97476       };
97477     } catch (Dali::DaliException e) {
97478       {
97479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97480       };
97481     } catch (...) {
97482       {
97483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97484       };
97485     }
97486   }
97487
97488   jresult = (void *)result;
97489   return jresult;
97490 }
97491
97492
97493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97494   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97495
97496   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97497   {
97498     try {
97499       delete arg1;
97500     } catch (std::out_of_range& e) {
97501       {
97502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97503       };
97504     } catch (std::exception& e) {
97505       {
97506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97507       };
97508     } catch (Dali::DaliException e) {
97509       {
97510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97511       };
97512     } catch (...) {
97513       {
97514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97515       };
97516     }
97517   }
97518
97519 }
97520
97521
97522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97523   unsigned int jresult ;
97524   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97525   bool result;
97526
97527   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97528   {
97529     try {
97530       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97531     } catch (std::out_of_range& e) {
97532       {
97533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97534       };
97535     } catch (std::exception& e) {
97536       {
97537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97538       };
97539     } catch (Dali::DaliException e) {
97540       {
97541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97542       };
97543     } catch (...) {
97544       {
97545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97546       };
97547     }
97548   }
97549
97550   jresult = result;
97551   return jresult;
97552 }
97553
97554
97555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97556   unsigned long jresult ;
97557   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97558   std::size_t result;
97559
97560   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97561   {
97562     try {
97563       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97564     } catch (std::out_of_range& e) {
97565       {
97566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97567       };
97568     } catch (std::exception& e) {
97569       {
97570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97571       };
97572     } catch (Dali::DaliException e) {
97573       {
97574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97575       };
97576     } catch (...) {
97577       {
97578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97579       };
97580     }
97581   }
97582
97583   jresult = (unsigned long)result;
97584   return jresult;
97585 }
97586
97587
97588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97589   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97590   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97591
97592   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97593   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97594   {
97595     try {
97596       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97597     } catch (std::out_of_range& e) {
97598       {
97599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97600       };
97601     } catch (std::exception& e) {
97602       {
97603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97604       };
97605     } catch (Dali::DaliException e) {
97606       {
97607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97608       };
97609     } catch (...) {
97610       {
97611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97612       };
97613     }
97614   }
97615
97616 }
97617
97618
97619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97620   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97621   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97622
97623   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97624   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97625   {
97626     try {
97627       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97628     } catch (std::out_of_range& e) {
97629       {
97630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97631       };
97632     } catch (std::exception& e) {
97633       {
97634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97635       };
97636     } catch (Dali::DaliException e) {
97637       {
97638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97639       };
97640     } catch (...) {
97641       {
97642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97643       };
97644     }
97645   }
97646
97647 }
97648
97649
97650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97651   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97652   Dali::Toolkit::PageTurnView arg2 ;
97653   Dali::Toolkit::PageTurnView *argp2 ;
97654
97655   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97656   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97657   if (!argp2) {
97658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97659     return ;
97660   }
97661   arg2 = *argp2;
97662   {
97663     try {
97664       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97665     } catch (std::out_of_range& e) {
97666       {
97667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97668       };
97669     } catch (std::exception& e) {
97670       {
97671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97672       };
97673     } catch (Dali::DaliException e) {
97674       {
97675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97676       };
97677     } catch (...) {
97678       {
97679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97680       };
97681     }
97682   }
97683
97684 }
97685
97686
97687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97688   void * jresult ;
97689   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97690
97691   {
97692     try {
97693       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97694     } catch (std::out_of_range& e) {
97695       {
97696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97697       };
97698     } catch (std::exception& e) {
97699       {
97700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97701       };
97702     } catch (Dali::DaliException e) {
97703       {
97704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97705       };
97706     } catch (...) {
97707       {
97708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97709       };
97710     }
97711   }
97712
97713   jresult = (void *)result;
97714   return jresult;
97715 }
97716
97717
97718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97719   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97720
97721   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97722   {
97723     try {
97724       delete arg1;
97725     } catch (std::out_of_range& e) {
97726       {
97727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97728       };
97729     } catch (std::exception& e) {
97730       {
97731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97732       };
97733     } catch (Dali::DaliException e) {
97734       {
97735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97736       };
97737     } catch (...) {
97738       {
97739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97740       };
97741     }
97742   }
97743
97744 }
97745
97746
97747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97748   unsigned int jresult ;
97749   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97750   bool result;
97751
97752   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97753   {
97754     try {
97755       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);
97756     } catch (std::out_of_range& e) {
97757       {
97758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97759       };
97760     } catch (std::exception& e) {
97761       {
97762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97763       };
97764     } catch (Dali::DaliException e) {
97765       {
97766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97767       };
97768     } catch (...) {
97769       {
97770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97771       };
97772     }
97773   }
97774
97775   jresult = result;
97776   return jresult;
97777 }
97778
97779
97780 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97781   unsigned long jresult ;
97782   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97783   std::size_t result;
97784
97785   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97786   {
97787     try {
97788       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);
97789     } catch (std::out_of_range& e) {
97790       {
97791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97792       };
97793     } catch (std::exception& e) {
97794       {
97795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97796       };
97797     } catch (Dali::DaliException e) {
97798       {
97799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97800       };
97801     } catch (...) {
97802       {
97803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97804       };
97805     }
97806   }
97807
97808   jresult = (unsigned long)result;
97809   return jresult;
97810 }
97811
97812
97813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97814   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97815   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97816
97817   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97818   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97819   {
97820     try {
97821       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97822     } catch (std::out_of_range& e) {
97823       {
97824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97825       };
97826     } catch (std::exception& e) {
97827       {
97828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97829       };
97830     } catch (Dali::DaliException e) {
97831       {
97832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97833       };
97834     } catch (...) {
97835       {
97836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97837       };
97838     }
97839   }
97840
97841 }
97842
97843
97844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97845   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97846   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97847
97848   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97849   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97850   {
97851     try {
97852       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97853     } catch (std::out_of_range& e) {
97854       {
97855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97856       };
97857     } catch (std::exception& e) {
97858       {
97859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97860       };
97861     } catch (Dali::DaliException e) {
97862       {
97863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97864       };
97865     } catch (...) {
97866       {
97867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97868       };
97869     }
97870   }
97871
97872 }
97873
97874
97875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97876   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97877   Dali::Toolkit::ProgressBar arg2 ;
97878   float arg3 ;
97879   float arg4 ;
97880   Dali::Toolkit::ProgressBar *argp2 ;
97881
97882   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97883   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97884   if (!argp2) {
97885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97886     return ;
97887   }
97888   arg2 = *argp2;
97889   arg3 = (float)jarg3;
97890   arg4 = (float)jarg4;
97891   {
97892     try {
97893       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97894     } catch (std::out_of_range& e) {
97895       {
97896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97897       };
97898     } catch (std::exception& e) {
97899       {
97900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97901       };
97902     } catch (Dali::DaliException e) {
97903       {
97904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97905       };
97906     } catch (...) {
97907       {
97908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97909       };
97910     }
97911   }
97912
97913 }
97914
97915
97916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97917   void * jresult ;
97918   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97919
97920   {
97921     try {
97922       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97923     } catch (std::out_of_range& e) {
97924       {
97925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97926       };
97927     } catch (std::exception& e) {
97928       {
97929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97930       };
97931     } catch (Dali::DaliException e) {
97932       {
97933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97934       };
97935     } catch (...) {
97936       {
97937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97938       };
97939     }
97940   }
97941
97942   jresult = (void *)result;
97943   return jresult;
97944 }
97945
97946
97947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97948   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97949
97950   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97951   {
97952     try {
97953       delete arg1;
97954     } catch (std::out_of_range& e) {
97955       {
97956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97957       };
97958     } catch (std::exception& e) {
97959       {
97960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97961       };
97962     } catch (Dali::DaliException e) {
97963       {
97964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97965       };
97966     } catch (...) {
97967       {
97968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97969       };
97970     }
97971   }
97972
97973 }
97974
97975
97976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97977   unsigned int jresult ;
97978   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97979   bool result;
97980
97981   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97982   {
97983     try {
97984       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);
97985     } catch (std::out_of_range& e) {
97986       {
97987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97988       };
97989     } catch (std::exception& e) {
97990       {
97991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97992       };
97993     } catch (Dali::DaliException e) {
97994       {
97995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97996       };
97997     } catch (...) {
97998       {
97999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98000       };
98001     }
98002   }
98003
98004   jresult = result;
98005   return jresult;
98006 }
98007
98008
98009 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
98010   unsigned long jresult ;
98011   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98012   std::size_t result;
98013
98014   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98015   {
98016     try {
98017       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);
98018     } catch (std::out_of_range& e) {
98019       {
98020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98021       };
98022     } catch (std::exception& e) {
98023       {
98024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98025       };
98026     } catch (Dali::DaliException e) {
98027       {
98028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98029       };
98030     } catch (...) {
98031       {
98032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98033       };
98034     }
98035   }
98036
98037   jresult = (unsigned long)result;
98038   return jresult;
98039 }
98040
98041
98042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98043   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98044   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98045
98046   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98047   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98048   {
98049     try {
98050       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98051     } catch (std::out_of_range& e) {
98052       {
98053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98054       };
98055     } catch (std::exception& e) {
98056       {
98057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98058       };
98059     } catch (Dali::DaliException e) {
98060       {
98061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98062       };
98063     } catch (...) {
98064       {
98065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98066       };
98067     }
98068   }
98069
98070 }
98071
98072
98073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98074   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98075   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98076
98077   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98078   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98079   {
98080     try {
98081       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98082     } catch (std::out_of_range& e) {
98083       {
98084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98085       };
98086     } catch (std::exception& e) {
98087       {
98088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98089       };
98090     } catch (Dali::DaliException e) {
98091       {
98092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98093       };
98094     } catch (...) {
98095       {
98096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98097       };
98098     }
98099   }
98100
98101 }
98102
98103
98104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98105   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98106   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98107
98108   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98109   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98110   if (!arg2) {
98111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98112     return ;
98113   }
98114   {
98115     try {
98116       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98117     } catch (std::out_of_range& e) {
98118       {
98119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98120       };
98121     } catch (std::exception& e) {
98122       {
98123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98124       };
98125     } catch (Dali::DaliException e) {
98126       {
98127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98128       };
98129     } catch (...) {
98130       {
98131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98132       };
98133     }
98134   }
98135
98136 }
98137
98138
98139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98140   void * jresult ;
98141   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98142
98143   {
98144     try {
98145       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98146     } catch (std::out_of_range& e) {
98147       {
98148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98149       };
98150     } catch (std::exception& e) {
98151       {
98152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98153       };
98154     } catch (Dali::DaliException e) {
98155       {
98156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98157       };
98158     } catch (...) {
98159       {
98160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98161       };
98162     }
98163   }
98164
98165   jresult = (void *)result;
98166   return jresult;
98167 }
98168
98169
98170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98171   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98172
98173   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98174   {
98175     try {
98176       delete arg1;
98177     } catch (std::out_of_range& e) {
98178       {
98179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98180       };
98181     } catch (std::exception& e) {
98182       {
98183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98184       };
98185     } catch (Dali::DaliException e) {
98186       {
98187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98188       };
98189     } catch (...) {
98190       {
98191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98192       };
98193     }
98194   }
98195
98196 }
98197
98198
98199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98200   unsigned int jresult ;
98201   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98202   bool result;
98203
98204   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98205   {
98206     try {
98207       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98208     } catch (std::out_of_range& e) {
98209       {
98210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98211       };
98212     } catch (std::exception& e) {
98213       {
98214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98215       };
98216     } catch (Dali::DaliException e) {
98217       {
98218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98219       };
98220     } catch (...) {
98221       {
98222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98223       };
98224     }
98225   }
98226
98227   jresult = result;
98228   return jresult;
98229 }
98230
98231
98232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98233   unsigned long jresult ;
98234   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98235   std::size_t result;
98236
98237   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98238   {
98239     try {
98240       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98241     } catch (std::out_of_range& e) {
98242       {
98243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98244       };
98245     } catch (std::exception& e) {
98246       {
98247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98248       };
98249     } catch (Dali::DaliException e) {
98250       {
98251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98252       };
98253     } catch (...) {
98254       {
98255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98256       };
98257     }
98258   }
98259
98260   jresult = (unsigned long)result;
98261   return jresult;
98262 }
98263
98264
98265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98266   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98267   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98268
98269   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98270   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98271   {
98272     try {
98273       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98274     } catch (std::out_of_range& e) {
98275       {
98276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98277       };
98278     } catch (std::exception& e) {
98279       {
98280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98281       };
98282     } catch (Dali::DaliException e) {
98283       {
98284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98285       };
98286     } catch (...) {
98287       {
98288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98289       };
98290     }
98291   }
98292
98293 }
98294
98295
98296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98297   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98298   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98299
98300   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98301   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98302   {
98303     try {
98304       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98305     } catch (std::out_of_range& e) {
98306       {
98307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98308       };
98309     } catch (std::exception& e) {
98310       {
98311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98312       };
98313     } catch (Dali::DaliException e) {
98314       {
98315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98316       };
98317     } catch (...) {
98318       {
98319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98320       };
98321     }
98322   }
98323
98324 }
98325
98326
98327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98328   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98329   Dali::Vector2 *arg2 = 0 ;
98330
98331   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98332   arg2 = (Dali::Vector2 *)jarg2;
98333   if (!arg2) {
98334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98335     return ;
98336   }
98337   {
98338     try {
98339       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98340     } catch (std::out_of_range& e) {
98341       {
98342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98343       };
98344     } catch (std::exception& e) {
98345       {
98346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98347       };
98348     } catch (Dali::DaliException e) {
98349       {
98350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98351       };
98352     } catch (...) {
98353       {
98354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98355       };
98356     }
98357   }
98358
98359 }
98360
98361
98362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98363   void * jresult ;
98364   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98365
98366   {
98367     try {
98368       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98369     } catch (std::out_of_range& e) {
98370       {
98371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98372       };
98373     } catch (std::exception& e) {
98374       {
98375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98376       };
98377     } catch (Dali::DaliException e) {
98378       {
98379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98380       };
98381     } catch (...) {
98382       {
98383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98384       };
98385     }
98386   }
98387
98388   jresult = (void *)result;
98389   return jresult;
98390 }
98391
98392
98393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98394   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98395
98396   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98397   {
98398     try {
98399       delete arg1;
98400     } catch (std::out_of_range& e) {
98401       {
98402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98403       };
98404     } catch (std::exception& e) {
98405       {
98406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98407       };
98408     } catch (Dali::DaliException e) {
98409       {
98410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98411       };
98412     } catch (...) {
98413       {
98414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98415       };
98416     }
98417   }
98418
98419 }
98420
98421
98422
98423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98424   unsigned int jresult ;
98425   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98426   bool result;
98427
98428   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98429   {
98430     try {
98431       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);
98432     } catch (std::out_of_range& e) {
98433       {
98434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98435       };
98436     } catch (std::exception& e) {
98437       {
98438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98439       };
98440     } catch (Dali::DaliException e) {
98441       {
98442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98443       };
98444     } catch (...) {
98445       {
98446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98447       };
98448     }
98449   }
98450
98451   jresult = result;
98452   return jresult;
98453 }
98454
98455
98456 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98457   unsigned long jresult ;
98458   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98459   std::size_t result;
98460
98461   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98462   {
98463     try {
98464       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);
98465     } catch (std::out_of_range& e) {
98466       {
98467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98468       };
98469     } catch (std::exception& e) {
98470       {
98471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98472       };
98473     } catch (Dali::DaliException e) {
98474       {
98475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98476       };
98477     } catch (...) {
98478       {
98479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98480       };
98481     }
98482   }
98483
98484   jresult = (unsigned long)result;
98485   return jresult;
98486 }
98487
98488
98489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98490   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98491   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98492
98493   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98494   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98495   {
98496     try {
98497       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98498     } catch (std::out_of_range& e) {
98499       {
98500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98501       };
98502     } catch (std::exception& e) {
98503       {
98504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98505       };
98506     } catch (Dali::DaliException e) {
98507       {
98508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98509       };
98510     } catch (...) {
98511       {
98512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98513       };
98514     }
98515   }
98516
98517 }
98518
98519
98520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98521   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98522   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98523
98524   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98525   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98526   {
98527     try {
98528       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98529     } catch (std::out_of_range& e) {
98530       {
98531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98532       };
98533     } catch (std::exception& e) {
98534       {
98535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98536       };
98537     } catch (Dali::DaliException e) {
98538       {
98539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98540       };
98541     } catch (...) {
98542       {
98543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98544       };
98545     }
98546   }
98547
98548 }
98549
98550
98551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98552   unsigned int jresult ;
98553   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98554   Dali::Toolkit::Control arg2 ;
98555   Dali::KeyEvent *arg3 = 0 ;
98556   Dali::Toolkit::Control *argp2 ;
98557   bool result;
98558
98559   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98560   argp2 = (Dali::Toolkit::Control *)jarg2;
98561   if (!argp2) {
98562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98563     return 0;
98564   }
98565   arg2 = *argp2;
98566   arg3 = (Dali::KeyEvent *)jarg3;
98567   if (!arg3) {
98568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98569     return 0;
98570   }
98571   {
98572     try {
98573       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);
98574     } catch (std::out_of_range& e) {
98575       {
98576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98577       };
98578     } catch (std::exception& e) {
98579       {
98580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98581       };
98582     } catch (Dali::DaliException e) {
98583       {
98584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98585       };
98586     } catch (...) {
98587       {
98588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98589       };
98590     }
98591   }
98592
98593   jresult = result;
98594   return jresult;
98595 }
98596
98597
98598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98599   void * jresult ;
98600   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98601
98602   {
98603     try {
98604       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98605     } catch (std::out_of_range& e) {
98606       {
98607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98608       };
98609     } catch (std::exception& e) {
98610       {
98611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98612       };
98613     } catch (Dali::DaliException e) {
98614       {
98615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98616       };
98617     } catch (...) {
98618       {
98619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98620       };
98621     }
98622   }
98623
98624   jresult = (void *)result;
98625   return jresult;
98626 }
98627
98628
98629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98630   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98631
98632   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98633   {
98634     try {
98635       delete arg1;
98636     } catch (std::out_of_range& e) {
98637       {
98638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98639       };
98640     } catch (std::exception& e) {
98641       {
98642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98643       };
98644     } catch (Dali::DaliException e) {
98645       {
98646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98647       };
98648     } catch (...) {
98649       {
98650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98651       };
98652     }
98653   }
98654
98655 }
98656
98657
98658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98659   unsigned int jresult ;
98660   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98661   bool result;
98662
98663   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98664   {
98665     try {
98666       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98667     } catch (std::out_of_range& e) {
98668       {
98669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98670       };
98671     } catch (std::exception& e) {
98672       {
98673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98674       };
98675     } catch (Dali::DaliException e) {
98676       {
98677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98678       };
98679     } catch (...) {
98680       {
98681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98682       };
98683     }
98684   }
98685
98686   jresult = result;
98687   return jresult;
98688 }
98689
98690
98691 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98692   unsigned long jresult ;
98693   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98694   std::size_t result;
98695
98696   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98697   {
98698     try {
98699       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98700     } catch (std::out_of_range& e) {
98701       {
98702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98703       };
98704     } catch (std::exception& e) {
98705       {
98706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98707       };
98708     } catch (Dali::DaliException e) {
98709       {
98710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98711       };
98712     } catch (...) {
98713       {
98714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98715       };
98716     }
98717   }
98718
98719   jresult = (unsigned long)result;
98720   return jresult;
98721 }
98722
98723
98724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98725   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98726   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98727
98728   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98729   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98730   {
98731     try {
98732       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98733     } catch (std::out_of_range& e) {
98734       {
98735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98736       };
98737     } catch (std::exception& e) {
98738       {
98739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98740       };
98741     } catch (Dali::DaliException e) {
98742       {
98743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98744       };
98745     } catch (...) {
98746       {
98747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98748       };
98749     }
98750   }
98751
98752 }
98753
98754
98755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98756   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98757   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98758
98759   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98760   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98761   {
98762     try {
98763       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98764     } catch (std::out_of_range& e) {
98765       {
98766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98767       };
98768     } catch (std::exception& e) {
98769       {
98770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98771       };
98772     } catch (Dali::DaliException e) {
98773       {
98774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98775       };
98776     } catch (...) {
98777       {
98778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98779       };
98780     }
98781   }
98782
98783 }
98784
98785
98786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98787   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98788   Dali::Toolkit::Control arg2 ;
98789   Dali::Toolkit::Control *argp2 ;
98790
98791   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98792   argp2 = (Dali::Toolkit::Control *)jarg2;
98793   if (!argp2) {
98794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98795     return ;
98796   }
98797   arg2 = *argp2;
98798   {
98799     try {
98800       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98801     } catch (std::out_of_range& e) {
98802       {
98803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98804       };
98805     } catch (std::exception& e) {
98806       {
98807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98808       };
98809     } catch (Dali::DaliException e) {
98810       {
98811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98812       };
98813     } catch (...) {
98814       {
98815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98816       };
98817     }
98818   }
98819
98820 }
98821
98822
98823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98824   void * jresult ;
98825   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98826
98827   {
98828     try {
98829       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98830     } catch (std::out_of_range& e) {
98831       {
98832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98833       };
98834     } catch (std::exception& e) {
98835       {
98836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98837       };
98838     } catch (Dali::DaliException e) {
98839       {
98840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98841       };
98842     } catch (...) {
98843       {
98844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98845       };
98846     }
98847   }
98848
98849   jresult = (void *)result;
98850   return jresult;
98851 }
98852
98853
98854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98855   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98856
98857   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98858   {
98859     try {
98860       delete arg1;
98861     } catch (std::out_of_range& e) {
98862       {
98863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98864       };
98865     } catch (std::exception& e) {
98866       {
98867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98868       };
98869     } catch (Dali::DaliException e) {
98870       {
98871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98872       };
98873     } catch (...) {
98874       {
98875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98876       };
98877     }
98878   }
98879
98880 }
98881
98882
98883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98884   unsigned int jresult ;
98885   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98886   bool result;
98887
98888   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98889   {
98890     try {
98891       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98892     } catch (std::out_of_range& e) {
98893       {
98894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98895       };
98896     } catch (std::exception& e) {
98897       {
98898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98899       };
98900     } catch (Dali::DaliException e) {
98901       {
98902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98903       };
98904     } catch (...) {
98905       {
98906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98907       };
98908     }
98909   }
98910
98911   jresult = result;
98912   return jresult;
98913 }
98914
98915
98916 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98917   unsigned long jresult ;
98918   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98919   std::size_t result;
98920
98921   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98922   {
98923     try {
98924       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98925     } catch (std::out_of_range& e) {
98926       {
98927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98928       };
98929     } catch (std::exception& e) {
98930       {
98931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98932       };
98933     } catch (Dali::DaliException e) {
98934       {
98935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98936       };
98937     } catch (...) {
98938       {
98939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98940       };
98941     }
98942   }
98943
98944   jresult = (unsigned long)result;
98945   return jresult;
98946 }
98947
98948
98949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98950   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98951   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98952
98953   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98954   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98955   {
98956     try {
98957       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98958     } catch (std::out_of_range& e) {
98959       {
98960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98961       };
98962     } catch (std::exception& e) {
98963       {
98964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98965       };
98966     } catch (Dali::DaliException e) {
98967       {
98968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98969       };
98970     } catch (...) {
98971       {
98972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98973       };
98974     }
98975   }
98976
98977 }
98978
98979
98980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98981   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98982   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98983
98984   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98985   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98986   {
98987     try {
98988       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98989     } catch (std::out_of_range& e) {
98990       {
98991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98992       };
98993     } catch (std::exception& e) {
98994       {
98995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98996       };
98997     } catch (Dali::DaliException e) {
98998       {
98999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99000       };
99001     } catch (...) {
99002       {
99003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99004       };
99005     }
99006   }
99007
99008 }
99009
99010
99011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
99012   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99013   Dali::Toolkit::VideoView *arg2 = 0 ;
99014
99015   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99016   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99017   if (!arg2) {
99018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99019     return ;
99020   }
99021   {
99022     try {
99023       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99024     } catch (std::out_of_range& e) {
99025       {
99026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99027       };
99028     } catch (std::exception& e) {
99029       {
99030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99031       };
99032     } catch (Dali::DaliException e) {
99033       {
99034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99035       };
99036     } catch (...) {
99037       {
99038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99039       };
99040     }
99041   }
99042
99043 }
99044
99045
99046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99047   void * jresult ;
99048   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99049
99050   {
99051     try {
99052       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99053     } catch (std::out_of_range& e) {
99054       {
99055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99056       };
99057     } catch (std::exception& e) {
99058       {
99059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99060       };
99061     } catch (Dali::DaliException e) {
99062       {
99063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99064       };
99065     } catch (...) {
99066       {
99067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99068       };
99069     }
99070   }
99071
99072   jresult = (void *)result;
99073   return jresult;
99074 }
99075
99076
99077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99078   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99079
99080   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99081   {
99082     try {
99083       delete arg1;
99084     } catch (std::out_of_range& e) {
99085       {
99086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99087       };
99088     } catch (std::exception& e) {
99089       {
99090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99091       };
99092     } catch (Dali::DaliException e) {
99093       {
99094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99095       };
99096     } catch (...) {
99097       {
99098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99099       };
99100     }
99101   }
99102
99103 }
99104
99105
99106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99107   unsigned int jresult ;
99108   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99109   bool result;
99110
99111   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99112   {
99113     try {
99114       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99115     } catch (std::out_of_range& e) {
99116       {
99117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99118       };
99119     } catch (std::exception& e) {
99120       {
99121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99122       };
99123     } catch (Dali::DaliException e) {
99124       {
99125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99126       };
99127     } catch (...) {
99128       {
99129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99130       };
99131     }
99132   }
99133
99134   jresult = result;
99135   return jresult;
99136 }
99137
99138
99139 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99140   unsigned long jresult ;
99141   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99142   std::size_t result;
99143
99144   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99145   {
99146     try {
99147       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99148     } catch (std::out_of_range& e) {
99149       {
99150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99151       };
99152     } catch (std::exception& e) {
99153       {
99154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99155       };
99156     } catch (Dali::DaliException e) {
99157       {
99158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99159       };
99160     } catch (...) {
99161       {
99162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99163       };
99164     }
99165   }
99166
99167   jresult = (unsigned long)result;
99168   return jresult;
99169 }
99170
99171
99172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99173   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99174   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99175
99176   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99177   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99178   {
99179     try {
99180       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99181     } catch (std::out_of_range& e) {
99182       {
99183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99184       };
99185     } catch (std::exception& e) {
99186       {
99187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99188       };
99189     } catch (Dali::DaliException e) {
99190       {
99191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99192       };
99193     } catch (...) {
99194       {
99195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99196       };
99197     }
99198   }
99199
99200 }
99201
99202
99203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99204   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99205   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99206
99207   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99208   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99209   {
99210     try {
99211       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99212     } catch (std::out_of_range& e) {
99213       {
99214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99215       };
99216     } catch (std::exception& e) {
99217       {
99218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99219       };
99220     } catch (Dali::DaliException e) {
99221       {
99222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99223       };
99224     } catch (...) {
99225       {
99226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99227       };
99228     }
99229   }
99230
99231 }
99232
99233
99234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99235   unsigned int jresult ;
99236   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99237   Dali::Toolkit::Slider arg2 ;
99238   float arg3 ;
99239   Dali::Toolkit::Slider *argp2 ;
99240   bool result;
99241
99242   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99243   argp2 = (Dali::Toolkit::Slider *)jarg2;
99244   if (!argp2) {
99245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99246     return 0;
99247   }
99248   arg2 = *argp2;
99249   arg3 = (float)jarg3;
99250   {
99251     try {
99252       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99253     } catch (std::out_of_range& e) {
99254       {
99255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99256       };
99257     } catch (std::exception& e) {
99258       {
99259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99260       };
99261     } catch (Dali::DaliException e) {
99262       {
99263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99264       };
99265     } catch (...) {
99266       {
99267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99268       };
99269     }
99270   }
99271
99272   jresult = result;
99273   return jresult;
99274 }
99275
99276
99277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99278   void * jresult ;
99279   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99280
99281   {
99282     try {
99283       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99284     } catch (std::out_of_range& e) {
99285       {
99286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99287       };
99288     } catch (std::exception& e) {
99289       {
99290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99291       };
99292     } catch (Dali::DaliException e) {
99293       {
99294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99295       };
99296     } catch (...) {
99297       {
99298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99299       };
99300     }
99301   }
99302
99303   jresult = (void *)result;
99304   return jresult;
99305 }
99306
99307
99308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99309   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99310
99311   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99312   {
99313     try {
99314       delete arg1;
99315     } catch (std::out_of_range& e) {
99316       {
99317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99318       };
99319     } catch (std::exception& e) {
99320       {
99321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99322       };
99323     } catch (Dali::DaliException e) {
99324       {
99325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99326       };
99327     } catch (...) {
99328       {
99329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99330       };
99331     }
99332   }
99333
99334 }
99335
99336
99337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99338   unsigned int jresult ;
99339   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99340   bool result;
99341
99342   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99343   {
99344     try {
99345       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99346     } catch (std::out_of_range& e) {
99347       {
99348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99349       };
99350     } catch (std::exception& e) {
99351       {
99352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99353       };
99354     } catch (Dali::DaliException e) {
99355       {
99356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99357       };
99358     } catch (...) {
99359       {
99360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99361       };
99362     }
99363   }
99364
99365   jresult = result;
99366   return jresult;
99367 }
99368
99369
99370 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99371   unsigned long jresult ;
99372   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99373   std::size_t result;
99374
99375   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99376   {
99377     try {
99378       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99379     } catch (std::out_of_range& e) {
99380       {
99381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99382       };
99383     } catch (std::exception& e) {
99384       {
99385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99386       };
99387     } catch (Dali::DaliException e) {
99388       {
99389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99390       };
99391     } catch (...) {
99392       {
99393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99394       };
99395     }
99396   }
99397
99398   jresult = (unsigned long)result;
99399   return jresult;
99400 }
99401
99402
99403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99404   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99405   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99406
99407   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99408   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99409   {
99410     try {
99411       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99412     } catch (std::out_of_range& e) {
99413       {
99414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99415       };
99416     } catch (std::exception& e) {
99417       {
99418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99419       };
99420     } catch (Dali::DaliException e) {
99421       {
99422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99423       };
99424     } catch (...) {
99425       {
99426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99427       };
99428     }
99429   }
99430
99431 }
99432
99433
99434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99435   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99436   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99437
99438   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99439   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99440   {
99441     try {
99442       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99443     } catch (std::out_of_range& e) {
99444       {
99445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99446       };
99447     } catch (std::exception& e) {
99448       {
99449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99450       };
99451     } catch (Dali::DaliException e) {
99452       {
99453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99454       };
99455     } catch (...) {
99456       {
99457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99458       };
99459     }
99460   }
99461
99462 }
99463
99464
99465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99466   unsigned int jresult ;
99467   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99468   Dali::Toolkit::Slider arg2 ;
99469   int arg3 ;
99470   Dali::Toolkit::Slider *argp2 ;
99471   bool result;
99472
99473   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99474   argp2 = (Dali::Toolkit::Slider *)jarg2;
99475   if (!argp2) {
99476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99477     return 0;
99478   }
99479   arg2 = *argp2;
99480   arg3 = (int)jarg3;
99481   {
99482     try {
99483       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99484     } catch (std::out_of_range& e) {
99485       {
99486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99487       };
99488     } catch (std::exception& e) {
99489       {
99490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99491       };
99492     } catch (Dali::DaliException e) {
99493       {
99494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99495       };
99496     } catch (...) {
99497       {
99498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99499       };
99500     }
99501   }
99502
99503   jresult = result;
99504   return jresult;
99505 }
99506
99507
99508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99509   void * jresult ;
99510   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99511
99512   {
99513     try {
99514       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99515     } catch (std::out_of_range& e) {
99516       {
99517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99518       };
99519     } catch (std::exception& e) {
99520       {
99521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99522       };
99523     } catch (Dali::DaliException e) {
99524       {
99525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99526       };
99527     } catch (...) {
99528       {
99529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99530       };
99531     }
99532   }
99533
99534   jresult = (void *)result;
99535   return jresult;
99536 }
99537
99538
99539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99540   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99541
99542   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99543   {
99544     try {
99545       delete arg1;
99546     } catch (std::out_of_range& e) {
99547       {
99548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99549       };
99550     } catch (std::exception& e) {
99551       {
99552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99553       };
99554     } catch (Dali::DaliException e) {
99555       {
99556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99557       };
99558     } catch (...) {
99559       {
99560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99561       };
99562     }
99563   }
99564
99565 }
99566
99567
99568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99569   void * jresult ;
99570   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99571
99572   {
99573     try {
99574       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99575     } catch (std::out_of_range& e) {
99576       {
99577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99578       };
99579     } catch (std::exception& e) {
99580       {
99581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99582       };
99583     } catch (Dali::DaliException e) {
99584       {
99585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99586       };
99587     } catch (...) {
99588       {
99589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99590       };
99591     }
99592   }
99593
99594   jresult = (void *)result;
99595   return jresult;
99596 }
99597
99598
99599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99600   void * jresult ;
99601   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99602   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99603
99604   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99605   {
99606     try {
99607       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99608     } catch (std::out_of_range& e) {
99609       {
99610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99611       };
99612     } catch (std::exception& e) {
99613       {
99614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99615       };
99616     } catch (Dali::DaliException e) {
99617       {
99618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99619       };
99620     } catch (...) {
99621       {
99622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99623       };
99624     }
99625   }
99626
99627   jresult = (void *)result;
99628   return jresult;
99629 }
99630
99631
99632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99633   void * jresult ;
99634   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99635   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99636
99637   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99638   if (!arg1) {
99639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99640     return 0;
99641   }
99642   {
99643     try {
99644       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99645     } catch (std::out_of_range& e) {
99646       {
99647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99648       };
99649     } catch (std::exception& e) {
99650       {
99651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99652       };
99653     } catch (Dali::DaliException e) {
99654       {
99655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99656       };
99657     } catch (...) {
99658       {
99659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99660       };
99661     }
99662   }
99663
99664   jresult = (void *)result;
99665   return jresult;
99666 }
99667
99668
99669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99670   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99671
99672   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99673   {
99674     try {
99675       delete arg1;
99676     } catch (std::out_of_range& e) {
99677       {
99678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99679       };
99680     } catch (std::exception& e) {
99681       {
99682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99683       };
99684     } catch (Dali::DaliException e) {
99685       {
99686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99687       };
99688     } catch (...) {
99689       {
99690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99691       };
99692     }
99693   }
99694
99695 }
99696
99697
99698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99699   void * jresult ;
99700   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99701   Dali::Toolkit::Ruler *result = 0 ;
99702
99703   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99704   {
99705     try {
99706       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99707     } catch (std::out_of_range& e) {
99708       {
99709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99710       };
99711     } catch (std::exception& e) {
99712       {
99713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99714       };
99715     } catch (Dali::DaliException e) {
99716       {
99717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99718       };
99719     } catch (...) {
99720       {
99721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99722       };
99723     }
99724   }
99725
99726   jresult = (void *)result;
99727   return jresult;
99728 }
99729
99730
99731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99732   void * jresult ;
99733   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99734   Dali::Toolkit::Ruler *result = 0 ;
99735
99736   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99737   {
99738     try {
99739       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99740     } catch (std::out_of_range& e) {
99741       {
99742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99743       };
99744     } catch (std::exception& e) {
99745       {
99746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99747       };
99748     } catch (Dali::DaliException e) {
99749       {
99750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99751       };
99752     } catch (...) {
99753       {
99754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99755       };
99756     }
99757   }
99758
99759   jresult = (void *)result;
99760   return jresult;
99761 }
99762
99763
99764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99765   void * jresult ;
99766   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99767   Dali::Toolkit::Ruler *result = 0 ;
99768
99769   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99770   {
99771     try {
99772       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99773     } catch (std::out_of_range& e) {
99774       {
99775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99776       };
99777     } catch (std::exception& e) {
99778       {
99779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99780       };
99781     } catch (Dali::DaliException e) {
99782       {
99783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99784       };
99785     } catch (...) {
99786       {
99787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99788       };
99789     }
99790   }
99791
99792   jresult = (void *)result;
99793   return jresult;
99794 }
99795
99796
99797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99798   void * jresult ;
99799   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99800   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99801   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99802
99803   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99804   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99805   if (!arg2) {
99806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99807     return 0;
99808   }
99809   {
99810     try {
99811       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99812     } catch (std::out_of_range& e) {
99813       {
99814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99815       };
99816     } catch (std::exception& e) {
99817       {
99818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99819       };
99820     } catch (Dali::DaliException e) {
99821       {
99822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99823       };
99824     } catch (...) {
99825       {
99826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99827       };
99828     }
99829   }
99830
99831   jresult = (void *)result;
99832   return jresult;
99833 }
99834
99835
99836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99837   void * jresult ;
99838   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99839   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99840   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99841
99842   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99843   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99844   {
99845     try {
99846       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99847     } catch (std::out_of_range& e) {
99848       {
99849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99850       };
99851     } catch (std::exception& e) {
99852       {
99853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99854       };
99855     } catch (Dali::DaliException e) {
99856       {
99857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99858       };
99859     } catch (...) {
99860       {
99861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99862       };
99863     }
99864   }
99865
99866   jresult = (void *)result;
99867   return jresult;
99868 }
99869
99870
99871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99872   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99873
99874   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99875   {
99876     try {
99877       (arg1)->Reset();
99878     } catch (std::out_of_range& e) {
99879       {
99880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99881       };
99882     } catch (std::exception& e) {
99883       {
99884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99885       };
99886     } catch (Dali::DaliException e) {
99887       {
99888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99889       };
99890     } catch (...) {
99891       {
99892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99893       };
99894     }
99895   }
99896
99897 }
99898
99899
99900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99901   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99902   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99903
99904   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99905   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99906   {
99907     try {
99908       (arg1)->Reset(arg2);
99909     } catch (std::out_of_range& e) {
99910       {
99911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99912       };
99913     } catch (std::exception& e) {
99914       {
99915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99916       };
99917     } catch (Dali::DaliException e) {
99918       {
99919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99920       };
99921     } catch (...) {
99922       {
99923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99924       };
99925     }
99926   }
99927
99928 }
99929
99930
99931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99932   void * jresult ;
99933   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99934   Dali::Toolkit::Ruler *result = 0 ;
99935
99936   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99937   {
99938     try {
99939       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99940     } catch (std::out_of_range& e) {
99941       {
99942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99943       };
99944     } catch (std::exception& e) {
99945       {
99946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99947       };
99948     } catch (Dali::DaliException e) {
99949       {
99950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99951       };
99952     } catch (...) {
99953       {
99954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99955       };
99956     }
99957   }
99958
99959   jresult = (void *)result;
99960   return jresult;
99961 }
99962
99963
99964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99965   float jresult ;
99966   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99967   float arg2 ;
99968   float arg3 ;
99969   float result;
99970
99971   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99972   arg2 = (float)jarg2;
99973   arg3 = (float)jarg3;
99974   {
99975     try {
99976       result = (float)(*arg1)->Snap(arg2,arg3);
99977     } catch (std::out_of_range& e) {
99978       {
99979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99980       };
99981     } catch (std::exception& e) {
99982       {
99983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99984       };
99985     } catch (Dali::DaliException e) {
99986       {
99987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99988       };
99989     } catch (...) {
99990       {
99991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99992       };
99993     }
99994   }
99995
99996   jresult = result;
99997   return jresult;
99998 }
99999
100000
100001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
100002   float jresult ;
100003   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100004   float arg2 ;
100005   float result;
100006
100007   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100008   arg2 = (float)jarg2;
100009   {
100010     try {
100011       result = (float)(*arg1)->Snap(arg2);
100012     } catch (std::out_of_range& e) {
100013       {
100014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100015       };
100016     } catch (std::exception& e) {
100017       {
100018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100019       };
100020     } catch (Dali::DaliException e) {
100021       {
100022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100023       };
100024     } catch (...) {
100025       {
100026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100027       };
100028     }
100029   }
100030
100031   jresult = result;
100032   return jresult;
100033 }
100034
100035
100036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100037   float jresult ;
100038   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100039   unsigned int arg2 ;
100040   unsigned int *arg3 = 0 ;
100041   bool arg4 ;
100042   float result;
100043
100044   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100045   arg2 = (unsigned int)jarg2;
100046   arg3 = (unsigned int *)jarg3;
100047   arg4 = jarg4 ? true : false;
100048   {
100049     try {
100050       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100051     } catch (std::out_of_range& e) {
100052       {
100053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100054       };
100055     } catch (std::exception& e) {
100056       {
100057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100058       };
100059     } catch (Dali::DaliException e) {
100060       {
100061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100062       };
100063     } catch (...) {
100064       {
100065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100066       };
100067     }
100068   }
100069
100070   jresult = result;
100071   return jresult;
100072 }
100073
100074
100075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100076   unsigned int jresult ;
100077   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100078   float arg2 ;
100079   bool arg3 ;
100080   unsigned int result;
100081
100082   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100083   arg2 = (float)jarg2;
100084   arg3 = jarg3 ? true : false;
100085   {
100086     try {
100087       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100088     } catch (std::out_of_range& e) {
100089       {
100090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100091       };
100092     } catch (std::exception& e) {
100093       {
100094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100095       };
100096     } catch (Dali::DaliException e) {
100097       {
100098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100099       };
100100     } catch (...) {
100101       {
100102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100103       };
100104     }
100105   }
100106
100107   jresult = result;
100108   return jresult;
100109 }
100110
100111
100112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100113   unsigned int jresult ;
100114   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100115   unsigned int result;
100116
100117   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100118   {
100119     try {
100120       result = (unsigned int)(*arg1)->GetTotalPages();
100121     } catch (std::out_of_range& e) {
100122       {
100123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100124       };
100125     } catch (std::exception& e) {
100126       {
100127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100128       };
100129     } catch (Dali::DaliException e) {
100130       {
100131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100132       };
100133     } catch (...) {
100134       {
100135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100136       };
100137     }
100138   }
100139
100140   jresult = result;
100141   return jresult;
100142 }
100143
100144
100145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100146   int jresult ;
100147   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100148   Dali::Toolkit::Ruler::RulerType result;
100149
100150   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100151   {
100152     try {
100153       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100154     } catch (std::out_of_range& e) {
100155       {
100156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100157       };
100158     } catch (std::exception& e) {
100159       {
100160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100161       };
100162     } catch (Dali::DaliException e) {
100163       {
100164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100165       };
100166     } catch (...) {
100167       {
100168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100169       };
100170     }
100171   }
100172
100173   jresult = (int)result;
100174   return jresult;
100175 }
100176
100177
100178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100179   unsigned int jresult ;
100180   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100181   bool result;
100182
100183   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100184   {
100185     try {
100186       result = (bool)(*arg1)->IsEnabled();
100187     } catch (std::out_of_range& e) {
100188       {
100189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100190       };
100191     } catch (std::exception& e) {
100192       {
100193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100194       };
100195     } catch (Dali::DaliException e) {
100196       {
100197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100198       };
100199     } catch (...) {
100200       {
100201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100202       };
100203     }
100204   }
100205
100206   jresult = result;
100207   return jresult;
100208 }
100209
100210
100211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100212   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100213
100214   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100215   {
100216     try {
100217       (*arg1)->Enable();
100218     } catch (std::out_of_range& e) {
100219       {
100220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100221       };
100222     } catch (std::exception& e) {
100223       {
100224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100225       };
100226     } catch (Dali::DaliException e) {
100227       {
100228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100229       };
100230     } catch (...) {
100231       {
100232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100233       };
100234     }
100235   }
100236
100237 }
100238
100239
100240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100241   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100242
100243   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100244   {
100245     try {
100246       (*arg1)->Disable();
100247     } catch (std::out_of_range& e) {
100248       {
100249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100250       };
100251     } catch (std::exception& e) {
100252       {
100253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100254       };
100255     } catch (Dali::DaliException e) {
100256       {
100257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100258       };
100259     } catch (...) {
100260       {
100261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100262       };
100263     }
100264   }
100265
100266 }
100267
100268
100269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100270   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100271   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100272   Dali::Toolkit::RulerDomain *argp2 ;
100273
100274   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100275   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100276   if (!argp2) {
100277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100278     return ;
100279   }
100280   arg2 = *argp2;
100281   {
100282     try {
100283       (*arg1)->SetDomain(arg2);
100284     } catch (std::out_of_range& e) {
100285       {
100286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100287       };
100288     } catch (std::exception& e) {
100289       {
100290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100291       };
100292     } catch (Dali::DaliException e) {
100293       {
100294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100295       };
100296     } catch (...) {
100297       {
100298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100299       };
100300     }
100301   }
100302
100303 }
100304
100305
100306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100307   void * jresult ;
100308   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100309   Dali::Toolkit::RulerDomain *result = 0 ;
100310
100311   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100312   {
100313     try {
100314       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100315     } catch (std::out_of_range& e) {
100316       {
100317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100318       };
100319     } catch (std::exception& e) {
100320       {
100321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100322       };
100323     } catch (Dali::DaliException e) {
100324       {
100325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100326       };
100327     } catch (...) {
100328       {
100329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100330       };
100331     }
100332   }
100333
100334   jresult = (void *)result;
100335   return jresult;
100336 }
100337
100338
100339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100340   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100341
100342   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100343   {
100344     try {
100345       (*arg1)->DisableDomain();
100346     } catch (std::out_of_range& e) {
100347       {
100348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100349       };
100350     } catch (std::exception& e) {
100351       {
100352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100353       };
100354     } catch (Dali::DaliException e) {
100355       {
100356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100357       };
100358     } catch (...) {
100359       {
100360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100361       };
100362     }
100363   }
100364
100365 }
100366
100367
100368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100369   float jresult ;
100370   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100371   float arg2 ;
100372   float arg3 ;
100373   float arg4 ;
100374   float result;
100375
100376   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100377   arg2 = (float)jarg2;
100378   arg3 = (float)jarg3;
100379   arg4 = (float)jarg4;
100380   {
100381     try {
100382       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100383     } catch (std::out_of_range& e) {
100384       {
100385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100386       };
100387     } catch (std::exception& e) {
100388       {
100389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100390       };
100391     } catch (Dali::DaliException e) {
100392       {
100393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100394       };
100395     } catch (...) {
100396       {
100397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100398       };
100399     }
100400   }
100401
100402   jresult = result;
100403   return jresult;
100404 }
100405
100406
100407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100408   float jresult ;
100409   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100410   float arg2 ;
100411   float arg3 ;
100412   float result;
100413
100414   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100415   arg2 = (float)jarg2;
100416   arg3 = (float)jarg3;
100417   {
100418     try {
100419       result = (float)(*arg1)->Clamp(arg2,arg3);
100420     } catch (std::out_of_range& e) {
100421       {
100422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100423       };
100424     } catch (std::exception& e) {
100425       {
100426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100427       };
100428     } catch (Dali::DaliException e) {
100429       {
100430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100431       };
100432     } catch (...) {
100433       {
100434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100435       };
100436     }
100437   }
100438
100439   jresult = result;
100440   return jresult;
100441 }
100442
100443
100444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100445   float jresult ;
100446   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100447   float arg2 ;
100448   float result;
100449
100450   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100451   arg2 = (float)jarg2;
100452   {
100453     try {
100454       result = (float)(*arg1)->Clamp(arg2);
100455     } catch (std::out_of_range& e) {
100456       {
100457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100458       };
100459     } catch (std::exception& e) {
100460       {
100461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100462       };
100463     } catch (Dali::DaliException e) {
100464       {
100465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100466       };
100467     } catch (...) {
100468       {
100469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100470       };
100471     }
100472   }
100473
100474   jresult = result;
100475   return jresult;
100476 }
100477
100478
100479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100480   float jresult ;
100481   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100482   float arg2 ;
100483   float arg3 ;
100484   float arg4 ;
100485   Dali::Toolkit::ClampState *arg5 = 0 ;
100486   float result;
100487
100488   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100489   arg2 = (float)jarg2;
100490   arg3 = (float)jarg3;
100491   arg4 = (float)jarg4;
100492   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100493   if (!arg5) {
100494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100495     return 0;
100496   }
100497   {
100498     try {
100499       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100500     } catch (std::out_of_range& e) {
100501       {
100502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100503       };
100504     } catch (std::exception& e) {
100505       {
100506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100507       };
100508     } catch (Dali::DaliException e) {
100509       {
100510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100511       };
100512     } catch (...) {
100513       {
100514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100515       };
100516     }
100517   }
100518
100519   jresult = result;
100520   return jresult;
100521 }
100522
100523
100524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100525   float jresult ;
100526   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100527   float arg2 ;
100528   float arg3 ;
100529   float arg4 ;
100530   float arg5 ;
100531   float result;
100532
100533   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100534   arg2 = (float)jarg2;
100535   arg3 = (float)jarg3;
100536   arg4 = (float)jarg4;
100537   arg5 = (float)jarg5;
100538   {
100539     try {
100540       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100541     } catch (std::out_of_range& e) {
100542       {
100543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100544       };
100545     } catch (std::exception& e) {
100546       {
100547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100548       };
100549     } catch (Dali::DaliException e) {
100550       {
100551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100552       };
100553     } catch (...) {
100554       {
100555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100556       };
100557     }
100558   }
100559
100560   jresult = result;
100561   return jresult;
100562 }
100563
100564
100565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100566   float jresult ;
100567   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100568   float arg2 ;
100569   float arg3 ;
100570   float arg4 ;
100571   float result;
100572
100573   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100574   arg2 = (float)jarg2;
100575   arg3 = (float)jarg3;
100576   arg4 = (float)jarg4;
100577   {
100578     try {
100579       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100580     } catch (std::out_of_range& e) {
100581       {
100582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100583       };
100584     } catch (std::exception& e) {
100585       {
100586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100587       };
100588     } catch (Dali::DaliException e) {
100589       {
100590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100591       };
100592     } catch (...) {
100593       {
100594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100595       };
100596     }
100597   }
100598
100599   jresult = result;
100600   return jresult;
100601 }
100602
100603
100604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100605   float jresult ;
100606   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100607   float arg2 ;
100608   float arg3 ;
100609   float result;
100610
100611   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100612   arg2 = (float)jarg2;
100613   arg3 = (float)jarg3;
100614   {
100615     try {
100616       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100617     } catch (std::out_of_range& e) {
100618       {
100619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100620       };
100621     } catch (std::exception& e) {
100622       {
100623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100624       };
100625     } catch (Dali::DaliException e) {
100626       {
100627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100628       };
100629     } catch (...) {
100630       {
100631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100632       };
100633     }
100634   }
100635
100636   jresult = result;
100637   return jresult;
100638 }
100639
100640
100641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100642   float jresult ;
100643   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100644   float arg2 ;
100645   float result;
100646
100647   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100648   arg2 = (float)jarg2;
100649   {
100650     try {
100651       result = (float)(*arg1)->SnapAndClamp(arg2);
100652     } catch (std::out_of_range& e) {
100653       {
100654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100655       };
100656     } catch (std::exception& e) {
100657       {
100658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100659       };
100660     } catch (Dali::DaliException e) {
100661       {
100662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100663       };
100664     } catch (...) {
100665       {
100666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100667       };
100668     }
100669   }
100670
100671   jresult = result;
100672   return jresult;
100673 }
100674
100675
100676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100677   float jresult ;
100678   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100679   float arg2 ;
100680   float arg3 ;
100681   float arg4 ;
100682   float arg5 ;
100683   Dali::Toolkit::ClampState *arg6 = 0 ;
100684   float result;
100685
100686   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100687   arg2 = (float)jarg2;
100688   arg3 = (float)jarg3;
100689   arg4 = (float)jarg4;
100690   arg5 = (float)jarg5;
100691   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100692   if (!arg6) {
100693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100694     return 0;
100695   }
100696   {
100697     try {
100698       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100699     } catch (std::out_of_range& e) {
100700       {
100701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100702       };
100703     } catch (std::exception& e) {
100704       {
100705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100706       };
100707     } catch (Dali::DaliException e) {
100708       {
100709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100710       };
100711     } catch (...) {
100712       {
100713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100714       };
100715     }
100716   }
100717
100718   jresult = result;
100719   return jresult;
100720 }
100721
100722
100723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100724   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100725
100726   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100727   {
100728     try {
100729       (*arg1)->Reference();
100730     } catch (std::out_of_range& e) {
100731       {
100732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100733       };
100734     } catch (std::exception& e) {
100735       {
100736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100737       };
100738     } catch (Dali::DaliException e) {
100739       {
100740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100741       };
100742     } catch (...) {
100743       {
100744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100745       };
100746     }
100747   }
100748
100749 }
100750
100751
100752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100753   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100754
100755   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100756   {
100757     try {
100758       (*arg1)->Unreference();
100759     } catch (std::out_of_range& e) {
100760       {
100761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100762       };
100763     } catch (std::exception& e) {
100764       {
100765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100766       };
100767     } catch (Dali::DaliException e) {
100768       {
100769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100770       };
100771     } catch (...) {
100772       {
100773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100774       };
100775     }
100776   }
100777
100778 }
100779
100780
100781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100782   int jresult ;
100783   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100784   int result;
100785
100786   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100787   {
100788     try {
100789       result = (int)(*arg1)->ReferenceCount();
100790     } catch (std::out_of_range& e) {
100791       {
100792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100793       };
100794     } catch (std::exception& e) {
100795       {
100796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100797       };
100798     } catch (Dali::DaliException e) {
100799       {
100800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100801       };
100802     } catch (...) {
100803       {
100804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100805       };
100806     }
100807   }
100808
100809   jresult = result;
100810   return jresult;
100811 }
100812
100813
100814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100815   unsigned int jresult ;
100816   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100817   bool result;
100818
100819   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100820   {
100821     try {
100822       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100823     } catch (std::out_of_range& e) {
100824       {
100825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100826       };
100827     } catch (std::exception& e) {
100828       {
100829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100830       };
100831     } catch (Dali::DaliException e) {
100832       {
100833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100834       };
100835     } catch (...) {
100836       {
100837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100838       };
100839     }
100840   }
100841
100842   jresult = result;
100843   return jresult;
100844 }
100845
100846
100847 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100848   unsigned long jresult ;
100849   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100850   std::size_t result;
100851
100852   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100853   {
100854     try {
100855       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100856     } catch (std::out_of_range& e) {
100857       {
100858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100859       };
100860     } catch (std::exception& e) {
100861       {
100862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100863       };
100864     } catch (Dali::DaliException e) {
100865       {
100866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100867       };
100868     } catch (...) {
100869       {
100870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100871       };
100872     }
100873   }
100874
100875   jresult = (unsigned long)result;
100876   return jresult;
100877 }
100878
100879
100880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100881   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100882   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100883
100884   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100885   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100886   {
100887     try {
100888       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100889     } catch (std::out_of_range& e) {
100890       {
100891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100892       };
100893     } catch (std::exception& e) {
100894       {
100895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100896       };
100897     } catch (Dali::DaliException e) {
100898       {
100899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100900       };
100901     } catch (...) {
100902       {
100903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100904       };
100905     }
100906   }
100907
100908 }
100909
100910
100911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100912   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100913   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100914
100915   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100916   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100917   {
100918     try {
100919       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100920     } catch (std::out_of_range& e) {
100921       {
100922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100923       };
100924     } catch (std::exception& e) {
100925       {
100926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100927       };
100928     } catch (Dali::DaliException e) {
100929       {
100930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100931       };
100932     } catch (...) {
100933       {
100934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100935       };
100936     }
100937   }
100938
100939 }
100940
100941
100942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100943   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100944   Dali::Toolkit::Control arg2 ;
100945   Dali::Toolkit::Control *argp2 ;
100946
100947   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100948   argp2 = (Dali::Toolkit::Control *)jarg2;
100949   if (!argp2) {
100950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100951     return ;
100952   }
100953   arg2 = *argp2;
100954   {
100955     try {
100956       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100957     } catch (std::out_of_range& e) {
100958       {
100959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100960       };
100961     } catch (std::exception& e) {
100962       {
100963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100964       };
100965     } catch (Dali::DaliException e) {
100966       {
100967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100968       };
100969     } catch (...) {
100970       {
100971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100972       };
100973     }
100974   }
100975
100976 }
100977
100978
100979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100980   void * jresult ;
100981   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100982
100983   {
100984     try {
100985       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100986     } catch (std::out_of_range& e) {
100987       {
100988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100989       };
100990     } catch (std::exception& e) {
100991       {
100992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100993       };
100994     } catch (Dali::DaliException e) {
100995       {
100996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100997       };
100998     } catch (...) {
100999       {
101000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101001       };
101002     }
101003   }
101004
101005   jresult = (void *)result;
101006   return jresult;
101007 }
101008
101009
101010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
101011   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101012
101013   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101014   {
101015     try {
101016       delete arg1;
101017     } catch (std::out_of_range& e) {
101018       {
101019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101020       };
101021     } catch (std::exception& e) {
101022       {
101023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101024       };
101025     } catch (Dali::DaliException e) {
101026       {
101027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101028       };
101029     } catch (...) {
101030       {
101031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101032       };
101033     }
101034   }
101035
101036 }
101037
101038 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101039   Dali::RefObject *result = NULL;
101040
101041   if (arg1)
101042   {
101043     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101044   }
101045   return result;
101046 }
101047
101048 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101049     return (Dali::RefObject *)jarg1;
101050 }
101051
101052 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101053     return (Dali::SignalObserver *)jarg1;
101054 }
101055
101056 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101057     return (Dali::ConnectionTrackerInterface *)jarg1;
101058 }
101059
101060 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101061     return (Dali::BaseHandle *)jarg1;
101062 }
101063
101064 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101065     return (Dali::BaseHandle *)jarg1;
101066 }
101067
101068 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101069     return (Dali::BaseHandle *)jarg1;
101070 }
101071
101072 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101073     return (Dali::BaseHandle *)jarg1;
101074 }
101075
101076 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101077     return (Dali::BaseHandle *)jarg1;
101078 }
101079
101080 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101081     return (Dali::BaseHandle *)jarg1;
101082 }
101083
101084 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101085     return (Dali::BaseHandle *)jarg1;
101086 }
101087
101088 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101089     return (Dali::BaseHandle *)jarg1;
101090 }
101091
101092 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101093     return (Dali::BaseHandle *)jarg1;
101094 }
101095
101096 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101097     return (Dali::BaseHandle *)jarg1;
101098 }
101099
101100 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101101     return (Dali::BaseHandle *)jarg1;
101102 }
101103
101104 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101105     return (Dali::BaseHandle *)jarg1;
101106 }
101107
101108 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101109     return (Dali::BaseHandle *)jarg1;
101110 }
101111
101112 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101113     return (Dali::Handle *)jarg1;
101114 }
101115
101116 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101117     return (Dali::Handle *)jarg1;
101118 }
101119
101120 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101121     return (Dali::BaseHandle *)jarg1;
101122 }
101123
101124 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101125     return (Dali::BaseHandle *)jarg1;
101126 }
101127
101128 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101129     return (Dali::Handle *)jarg1;
101130 }
101131
101132 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101133     return (Dali::BaseHandle *)jarg1;
101134 }
101135
101136 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101137     return (Dali::Handle *)jarg1;
101138 }
101139
101140 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101141     return (Dali::GestureDetector *)jarg1;
101142 }
101143
101144 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101145     return (Dali::Gesture *)jarg1;
101146 }
101147
101148 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101149     return (Dali::Handle *)jarg1;
101150 }
101151
101152 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101153     return (Dali::Actor *)jarg1;
101154 }
101155
101156 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101157     return (Dali::BaseHandle *)jarg1;
101158 }
101159
101160 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101161     return (Dali::RefObject *)jarg1;
101162 }
101163
101164 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101165     return (Dali::Actor *)jarg1;
101166 }
101167
101168 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101169     return (Dali::GestureDetector *)jarg1;
101170 }
101171
101172 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101173     return (Dali::Gesture *)jarg1;
101174 }
101175
101176 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101177     return (Dali::GestureDetector *)jarg1;
101178 }
101179
101180 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101181     return (Dali::Gesture *)jarg1;
101182 }
101183
101184 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101185     return (Dali::GestureDetector *)jarg1;
101186 }
101187
101188 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101189     return (Dali::Gesture *)jarg1;
101190 }
101191
101192 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101193     return (Dali::BaseHandle *)jarg1;
101194 }
101195
101196 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101197     return (Dali::Handle *)jarg1;
101198 }
101199
101200 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101201     return (Dali::Handle *)jarg1;
101202 }
101203
101204 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101205     return (Dali::Handle *)jarg1;
101206 }
101207
101208 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101209     return (Dali::Image *)jarg1;
101210 }
101211
101212 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101213     return (Dali::Image *)jarg1;
101214 }
101215
101216 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101217     return (Dali::Image *)jarg1;
101218 }
101219
101220 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101221     return (Dali::RefObject *)jarg1;
101222 }
101223
101224 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101225     return (Dali::Image *)jarg1;
101226 }
101227
101228 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101229     return (Dali::Image *)jarg1;
101230 }
101231
101232 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101233     return (Dali::ResourceImage *)jarg1;
101234 }
101235
101236 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101237     return (Dali::Actor *)jarg1;
101238 }
101239
101240 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101241     return (Dali::BaseHandle *)jarg1;
101242 }
101243
101244 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101245     return (Dali::BaseHandle *)jarg1;
101246 }
101247
101248
101249 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101250     return (Dali::BaseHandle *)jarg1;
101251 }
101252
101253 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101254     return (Dali::BaseHandle *)jarg1;
101255 }
101256
101257 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101258     return (Dali::CustomActorImpl *)jarg1;
101259 }
101260
101261 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101262     return (Dali::CustomActor *)jarg1;
101263 }
101264
101265 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101266     return (Dali::BaseHandle *)jarg1;
101267 }
101268
101269 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101270     return (Dali::Toolkit::Control *)jarg1;
101271 }
101272
101273 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101274     return (Dali::Toolkit::Control *)jarg1;
101275 }
101276
101277 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101278     return (Dali::Toolkit::Button *)jarg1;
101279 }
101280
101281 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101282     return (Dali::Toolkit::Button *)jarg1;
101283 }
101284
101285 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101286     return (Dali::Toolkit::Button *)jarg1;
101287 }
101288
101289 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101290     return (Dali::Toolkit::Control *)jarg1;
101291 }
101292
101293 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101294     return (Dali::Toolkit::Control *)jarg1;
101295 }
101296
101297 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101298     return (Dali::Toolkit::Control *)jarg1;
101299 }
101300
101301 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101302     return (Dali::Toolkit::Control *)jarg1;
101303 }
101304
101305 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101306     return (Dali::Toolkit::Control *)jarg1;
101307 }
101308
101309 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101310     return (Dali::RefObject *)jarg1;
101311 }
101312
101313 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101314     return (Dali::Toolkit::Scrollable *)jarg1;
101315 }
101316
101317 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101318     return (Dali::BaseHandle *)jarg1;
101319 }
101320
101321 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101322     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101323 }
101324
101325 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101326     return (Dali::RefObject *)jarg1;
101327 }
101328
101329 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101330     return (Dali::Toolkit::Ruler *)jarg1;
101331 }
101332
101333 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101334     return (Dali::Toolkit::Ruler *)jarg1;
101335 }
101336
101337 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101338     return (Dali::Toolkit::Scrollable *)jarg1;
101339 }
101340
101341 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101342     return (Dali::Toolkit::Control *)jarg1;
101343 }
101344
101345
101346 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101347     return (Dali::Toolkit::Control *)jarg1;
101348 }
101349
101350 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101351     return (Dali::BaseHandle *)jarg1;
101352 }
101353
101354 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101355     return (Dali::BaseHandle *)jarg1;
101356 }
101357
101358 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101359     return (Dali::Toolkit::Control *)jarg1;
101360 }
101361
101362 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101363     return (Dali::Toolkit::Control *)jarg1;
101364 }
101365
101366 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101367     return (Dali::Toolkit::Control *)jarg1;
101368 }
101369
101370 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101371     return (Dali::Toolkit::Control *)jarg1;
101372 }
101373
101374 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101375     return (Dali::Toolkit::Control *)jarg1;
101376 }
101377
101378 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101379     return (Dali::Toolkit::Control *)jarg1;
101380 }
101381
101382 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101383     return (Dali::Toolkit::PageTurnView *)jarg1;
101384 }
101385
101386 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101387     return (Dali::Toolkit::PageTurnView *)jarg1;
101388 }
101389
101390 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101391     return (Dali::Toolkit::Button *)jarg1;
101392 }
101393
101394 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101395     return (Dali::BaseHandle *)jarg1;
101396 }
101397
101398 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101399     return (Dali::BaseHandle *)jarg1;
101400 }
101401
101402 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101403     return (Dali::BaseHandle *)jarg1;
101404 }
101405
101406 /*
101407  * Widget binding
101408  */
101409 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101410     return (Dali::BaseHandle *)jarg1;
101411 }
101412
101413 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101414     return (Dali::BaseObject *)jarg1;
101415 }
101416
101417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101418   void * jresult ;
101419   Dali::Widget result;
101420
101421   {
101422     try {
101423       result = Dali::Widget::New();
101424     } catch (std::out_of_range& e) {
101425       {
101426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101427       };
101428     } catch (std::exception& e) {
101429       {
101430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101431       };
101432     } catch (...) {
101433       {
101434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101435       };
101436     }
101437   }
101438   jresult = new Dali::Widget((const Dali::Widget &)result);
101439   return jresult;
101440 }
101441
101442
101443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101444   void * jresult ;
101445   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101446   Dali::Widget result;
101447
101448   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101449
101450   if (!arg1) {
101451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101452     return 0;
101453   }
101454   {
101455     try {
101456       jresult = new Dali::Widget(arg1);
101457     } catch (std::out_of_range& e) {
101458       {
101459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101460       };
101461     } catch (std::exception& e) {
101462       {
101463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101464       };
101465     } catch (...) {
101466       {
101467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101468       };
101469     }
101470   }
101471   return jresult;
101472 }
101473
101474
101475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101476   void * jresult ;
101477   Dali::Widget *result = 0 ;
101478
101479   {
101480     try {
101481       result = (Dali::Widget *)new Dali::Widget();
101482     } catch (std::out_of_range& e) {
101483       {
101484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101485       };
101486     } catch (std::exception& e) {
101487       {
101488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101489       };
101490     } catch (...) {
101491       {
101492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101493       };
101494     }
101495   }
101496   jresult = (void *)result;
101497   return jresult;
101498 }
101499
101500
101501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101502   void * jresult ;
101503   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101504   Dali::Widget *arg2 = 0 ;
101505   Dali::Widget *result = 0 ;
101506
101507   arg1 = (Dali::Widget *)jarg1;
101508   arg2 = (Dali::Widget *)jarg2;
101509   if (!arg2) {
101510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101511     return 0;
101512   }
101513   {
101514     try {
101515       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101516     } catch (std::out_of_range& e) {
101517       {
101518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101519       };
101520     } catch (std::exception& e) {
101521       {
101522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101523       };
101524     } catch (...) {
101525       {
101526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101527       };
101528     }
101529   }
101530   jresult = (void *)result;
101531   return jresult;
101532 }
101533
101534
101535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101536   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101537
101538   arg1 = (Dali::Widget *)jarg1;
101539   {
101540     try {
101541       delete arg1;
101542     } catch (std::out_of_range& e) {
101543       {
101544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101545       };
101546     } catch (std::exception& e) {
101547       {
101548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101549       };
101550     } catch (...) {
101551       {
101552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101553       };
101554     }
101555   }
101556 }
101557
101558
101559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101560   void * jresult ;
101561   SwigDirector_WidgetImpl* result;
101562   {
101563     try {
101564       result = new SwigDirector_WidgetImpl();
101565     } catch (std::out_of_range& e) {
101566       {
101567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101568       };
101569     } catch (std::exception& e) {
101570       {
101571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101572       };
101573     } catch (...) {
101574       {
101575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101576       };
101577     }
101578   }
101579   jresult = result;
101580   return jresult;
101581 }
101582
101583
101584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101585   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101586   std::string *arg2 = 0 ;
101587   Dali::Window arg3 ;
101588   Dali::Window *argp3 ;
101589
101590   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101591   if (!jarg2) {
101592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101593     return ;
101594   }
101595   std::string arg2_str(jarg2);
101596   arg2 = &arg2_str;
101597   argp3 = (Dali::Window *)jarg3;
101598   if (!argp3) {
101599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101600     return ;
101601   }
101602   arg3 = *argp3;
101603   {
101604     try {
101605       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101606     } catch (std::out_of_range& e) {
101607       {
101608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101609       };
101610     } catch (std::exception& e) {
101611       {
101612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101613       };
101614     } catch (...) {
101615       {
101616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101617       };
101618     }
101619   }
101620 }
101621
101622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101623   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101624   std::string *arg2 = 0 ;
101625   Dali::Window arg3 ;
101626   Dali::Window *argp3 ;
101627
101628   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101629   if (!jarg2) {
101630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101631     return ;
101632   }
101633   std::string arg2_str(jarg2);
101634   arg2 = &arg2_str;
101635   argp3 = (Dali::Window *)jarg3;
101636   if (!argp3) {
101637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101638     return ;
101639   }
101640   arg3 = *argp3;
101641   {
101642     try {
101643       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101644     } catch (std::out_of_range& e) {
101645       {
101646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101647       };
101648     } catch (std::exception& e) {
101649       {
101650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101651       };
101652     } catch (...) {
101653       {
101654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101655       };
101656     }
101657   }
101658 }
101659
101660
101661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101662   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101663   std::string *arg2 = 0 ;
101664   Dali::Widget::Termination arg3 ;
101665
101666   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101667   if (!jarg2) {
101668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101669     return ;
101670   }
101671   std::string arg2_str(jarg2);
101672   arg2 = &arg2_str;
101673   arg3 = (Dali::Widget::Termination)jarg3;
101674   {
101675     try {
101676       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101677     } catch (std::out_of_range& e) {
101678       {
101679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101680       };
101681     } catch (std::exception& e) {
101682       {
101683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101684       };
101685     } catch (...) {
101686       {
101687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101688       };
101689     }
101690   }
101691 }
101692
101693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101694   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101695   std::string *arg2 = 0 ;
101696   Dali::Widget::Termination arg3 ;
101697
101698   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101699   if (!jarg2) {
101700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101701     return ;
101702   }
101703   std::string arg2_str(jarg2);
101704   arg2 = &arg2_str;
101705   arg3 = (Dali::Widget::Termination)jarg3;
101706   {
101707     try {
101708       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101709     } catch (std::out_of_range& e) {
101710       {
101711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101712       };
101713     } catch (std::exception& e) {
101714       {
101715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101716       };
101717     } catch (...) {
101718       {
101719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101720       };
101721     }
101722   }
101723 }
101724
101725
101726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101727   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101728
101729   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101730   {
101731     try {
101732       (arg1)->OnPause();
101733     } catch (std::out_of_range& e) {
101734       {
101735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101736       };
101737     } catch (std::exception& e) {
101738       {
101739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101740       };
101741     } catch (...) {
101742       {
101743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101744       };
101745     }
101746   }
101747 }
101748
101749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101750   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101751
101752   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101753   {
101754     try {
101755       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101756     } catch (std::out_of_range& e) {
101757       {
101758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101759       };
101760     } catch (std::exception& e) {
101761       {
101762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101763       };
101764     } catch (...) {
101765       {
101766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101767       };
101768     }
101769   }
101770 }
101771
101772
101773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101774   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101775
101776   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101777   {
101778     try {
101779       (arg1)->OnResume();
101780     } catch (std::out_of_range& e) {
101781       {
101782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101783       };
101784     } catch (std::exception& e) {
101785       {
101786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101787       };
101788     } catch (...) {
101789       {
101790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101791       };
101792     }
101793   }
101794 }
101795
101796
101797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101798   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101799
101800   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101801   {
101802     try {
101803       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101804     } catch (std::out_of_range& e) {
101805       {
101806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101807       };
101808     } catch (std::exception& e) {
101809       {
101810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101811       };
101812     } catch (...) {
101813       {
101814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101815       };
101816     }
101817   }
101818 }
101819
101820
101821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101822   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101823   Dali::Window arg2 ;
101824   Dali::Window *argp2 ;
101825
101826   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101827   argp2 = (Dali::Window *)jarg2;
101828   if (!argp2) {
101829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101830     return ;
101831   }
101832   arg2 = *argp2;
101833   {
101834     try {
101835       (arg1)->OnResize(arg2);
101836     } catch (std::out_of_range& e) {
101837       {
101838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101839       };
101840     } catch (std::exception& e) {
101841       {
101842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101843       };
101844     } catch (...) {
101845       {
101846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101847       };
101848     }
101849   }
101850 }
101851
101852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101853   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101854   Dali::Window arg2 ;
101855   Dali::Window *argp2 ;
101856
101857   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101858   argp2 = (Dali::Window *)jarg2;
101859   if (!argp2) {
101860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101861     return ;
101862   }
101863   arg2 = *argp2;
101864   {
101865     try {
101866       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101867     } catch (std::out_of_range& e) {
101868       {
101869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101870       };
101871     } catch (std::exception& e) {
101872       {
101873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101874       };
101875     } catch (...) {
101876       {
101877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101878       };
101879     }
101880   }
101881 }
101882
101883
101884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101885   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101886   std::string *arg2 = 0 ;
101887   int arg3 ;
101888
101889   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101890   if (!jarg2) {
101891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101892     return ;
101893   }
101894   std::string arg2_str(jarg2);
101895   arg2 = &arg2_str;
101896   arg3 = (int)jarg3;
101897   {
101898     try {
101899       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101900     } catch (std::out_of_range& e) {
101901       {
101902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101903       };
101904     } catch (std::exception& e) {
101905       {
101906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101907       };
101908     } catch (...) {
101909       {
101910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101911       };
101912     }
101913   }
101914 }
101915
101916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101917   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101918   std::string *arg2 = 0 ;
101919   int arg3 ;
101920
101921   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101922   if (!jarg2) {
101923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101924     return ;
101925   }
101926   std::string arg2_str(jarg2);
101927   arg2 = &arg2_str;
101928   arg3 = (int)jarg3;
101929   {
101930     try {
101931       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101932     } catch (std::out_of_range& e) {
101933       {
101934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101935       };
101936     } catch (std::exception& e) {
101937       {
101938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101939       };
101940     } catch (...) {
101941       {
101942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101943       };
101944     }
101945   }
101946 }
101947
101948
101949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101950   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101951   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101952   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101953
101954   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101955   arg2 = (Dali::SlotObserver *)jarg2;
101956   arg3 = (Dali::CallbackBase *)jarg3;
101957   {
101958     try {
101959       (arg1)->SignalConnected(arg2,arg3);
101960     } catch (std::out_of_range& e) {
101961       {
101962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101963       };
101964     } catch (std::exception& e) {
101965       {
101966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101967       };
101968     } catch (...) {
101969       {
101970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101971       };
101972     }
101973   }
101974 }
101975
101976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101977   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101978   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101979   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101980
101981   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101982   arg2 = (Dali::SlotObserver *)jarg2;
101983   arg3 = (Dali::CallbackBase *)jarg3;
101984   {
101985     try {
101986       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101987     } catch (std::out_of_range& e) {
101988       {
101989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101990       };
101991     } catch (std::exception& e) {
101992       {
101993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101994       };
101995     } catch (...) {
101996       {
101997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101998       };
101999     }
102000   }
102001 }
102002
102003
102004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
102005   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102006   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102007   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102008
102009   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102010   arg2 = (Dali::SlotObserver *)jarg2;
102011   arg3 = (Dali::CallbackBase *)jarg3;
102012   {
102013     try {
102014       (arg1)->SignalDisconnected(arg2,arg3);
102015     } catch (std::out_of_range& e) {
102016       {
102017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102018       };
102019     } catch (std::exception& e) {
102020       {
102021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102022       };
102023     } catch (...) {
102024       {
102025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102026       };
102027     }
102028   }
102029 }
102030
102031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102032   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102033   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102034   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102035
102036   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102037   arg2 = (Dali::SlotObserver *)jarg2;
102038   arg3 = (Dali::CallbackBase *)jarg3;
102039   {
102040     try {
102041       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102042     } catch (std::out_of_range& e) {
102043       {
102044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102045       };
102046     } catch (std::exception& e) {
102047       {
102048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102049       };
102050     } catch (...) {
102051       {
102052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102053       };
102054     }
102055   }
102056 }
102057
102058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102059   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102060   std::string *arg2 = 0 ;
102061
102062   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102063   if (!jarg2) {
102064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102065     return ;
102066   }
102067   std::string arg2_str(jarg2);
102068   arg2 = &arg2_str;
102069   {
102070     try {
102071       (arg1)->SetContentInfo((std::string const &)*arg2);
102072     } catch (std::out_of_range& e) {
102073       {
102074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102075       };
102076     } catch (std::exception& e) {
102077       {
102078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102079       };
102080     } catch (...) {
102081       {
102082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102083       };
102084     }
102085   }
102086 }
102087
102088
102089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102090   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102091   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102092
102093   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102094   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102095   {
102096     try {
102097       (arg1)->SetImpl(arg2);
102098     } catch (std::out_of_range& e) {
102099       {
102100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102101       };
102102     } catch (std::exception& e) {
102103       {
102104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102105       };
102106     } catch (...) {
102107       {
102108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102109       };
102110     }
102111   }
102112 }
102113
102114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_director_connect(void *objarg, SwigDirector_WidgetImpl::SWIG_Callback0_t callback0, SwigDirector_WidgetImpl::SWIG_Callback1_t callback1, SwigDirector_WidgetImpl::SWIG_Callback2_t callback2, SwigDirector_WidgetImpl::SWIG_Callback3_t callback3, SwigDirector_WidgetImpl::SWIG_Callback4_t callback4, SwigDirector_WidgetImpl::SWIG_Callback5_t callback5, SwigDirector_WidgetImpl::SWIG_Callback6_t callback6, SwigDirector_WidgetImpl::SWIG_Callback7_t callback7) {
102115
102116   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102117   if (director) {
102118     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102119   }
102120 }
102121
102122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102123   void * jresult ;
102124   Dali::Widget *arg1 = 0 ;
102125   SwigDirector_WidgetImpl *result = 0 ;
102126
102127   arg1 = (Dali::Widget *)jarg1;
102128   if (!arg1) {
102129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102130     return 0;
102131   }
102132   {
102133     try {
102134       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102135     } catch (std::out_of_range& e) {
102136       {
102137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102138       };
102139     } catch (std::exception& e) {
102140       {
102141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102142       };
102143     } catch (...) {
102144       {
102145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102146       };
102147     }
102148   }
102149
102150   jresult = (void *)result;
102151   return jresult;
102152 }
102153
102154
102155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102156   void * jresult ;
102157   int *arg1 = (int *) 0 ;
102158   char ***arg2 ;
102159   std::string *arg3 = 0 ;
102160   Dali::WidgetApplication result;
102161   {
102162     int index = 0;
102163     int length = 0;
102164     char *retPtr;
102165     char *nextPtr;
102166     argWidgetC = jarg1;
102167     argWidgetV = new char*[jarg1 + 1];
102168
102169     retPtr = strtok_r( jarg2, " ", &nextPtr);
102170     if( retPtr )
102171     {
102172       length = strlen(retPtr);
102173     }
102174     argWidgetV[index] = new char[length + 1];
102175     if( retPtr )
102176     {
102177       strncpy(argWidgetV[index], retPtr, length);
102178     }
102179     argWidgetV[index][length] = '\0';
102180     index++;
102181
102182     while (index < jarg1)
102183     {
102184       length = 0;
102185       retPtr = strtok_r(NULL, " ", &nextPtr);
102186       if( retPtr )
102187       {
102188         length = strlen(retPtr);
102189       }
102190       argWidgetV[index] = new char[length + 1];
102191       if( retPtr )
102192       {
102193         strncpy(argWidgetV[index], retPtr, length);
102194       }
102195       argWidgetV[index][length] = '\0';
102196       index++;
102197     }
102198
102199     argWidgetV[jarg1] = NULL;
102200     argWidgetC = jarg1;
102201
102202     arg1 = &argWidgetC;
102203     arg2 = &argWidgetV;
102204   }
102205
102206   if (!jarg3) {
102207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102208     return 0;
102209   }
102210   std::string arg3_str(jarg3);
102211   arg3 = &arg3_str;
102212   {
102213     try {
102214       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102215     } catch (std::out_of_range& e) {
102216       {
102217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102218       };
102219     } catch (std::exception& e) {
102220       {
102221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102222       };
102223     } catch (...) {
102224       {
102225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102226       };
102227     }
102228   }
102229   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102230
102231   return jresult;
102232 }
102233
102234
102235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102236   void * jresult ;
102237   Dali::WidgetApplication *result = 0 ;
102238
102239   {
102240     try {
102241       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102242     } catch (std::out_of_range& e) {
102243       {
102244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102245       };
102246     } catch (std::exception& e) {
102247       {
102248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102249       };
102250     } catch (...) {
102251       {
102252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102253       };
102254     }
102255   }
102256   jresult = (void *)result;
102257   return jresult;
102258 }
102259
102260
102261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102262   void * jresult ;
102263   Dali::WidgetApplication *arg1 = 0 ;
102264   Dali::WidgetApplication *result = 0 ;
102265
102266   arg1 = (Dali::WidgetApplication *)jarg1;
102267   if (!arg1) {
102268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102269     return 0;
102270   }
102271   {
102272     try {
102273       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102274     } catch (std::out_of_range& e) {
102275       {
102276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102277       };
102278     } catch (std::exception& e) {
102279       {
102280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102281       };
102282     } catch (...) {
102283       {
102284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102285       };
102286     }
102287   }
102288   jresult = (void *)result;
102289   return jresult;
102290 }
102291
102292
102293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102294   void * jresult ;
102295   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102296   Dali::WidgetApplication *arg2 = 0 ;
102297   Dali::WidgetApplication *result = 0 ;
102298
102299   arg1 = (Dali::WidgetApplication *)jarg1;
102300   arg2 = (Dali::WidgetApplication *)jarg2;
102301   if (!arg2) {
102302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102303     return 0;
102304   }
102305   {
102306     try {
102307       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102308     } catch (std::out_of_range& e) {
102309       {
102310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102311       };
102312     } catch (std::exception& e) {
102313       {
102314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102315       };
102316     } catch (...) {
102317       {
102318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102319       };
102320     }
102321   }
102322   jresult = (void *)result;
102323   return jresult;
102324 }
102325
102326
102327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102328   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102329
102330   arg1 = (Dali::WidgetApplication *)jarg1;
102331   {
102332     try {
102333       delete arg1;
102334       if( argWidgetV )
102335       {
102336         // free string data
102337         for( int i=0; i < argWidgetC+1; i++)
102338         {
102339           delete [] argWidgetV[i];
102340         }
102341         delete [] argWidgetV;
102342       }
102343     } catch (std::out_of_range& e) {
102344       {
102345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102346       };
102347     } catch (std::exception& e) {
102348       {
102349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102350       };
102351     } catch (...) {
102352       {
102353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102354       };
102355     }
102356   }
102357 }
102358
102359
102360 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102361 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102362
102363 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102364 {
102365   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102366   return *widget;
102367 }
102368
102369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102370   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102371   std::string *arg2 = 0 ;
102372
102373   arg1 = (Dali::WidgetApplication *)jarg1;
102374   if (!jarg2) {
102375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102376     return ;
102377   }
102378   std::string arg2_str(*jarg2);
102379   arg2 = &arg2_str;
102380
102381   if(!_CSharpCreateWidgetFunction)
102382   {
102383     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102384   }
102385
102386   {
102387     try {
102388       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102389     } catch (std::out_of_range& e) {
102390       {
102391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102392       };
102393     } catch (std::exception& e) {
102394       {
102395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102396       };
102397     } catch (...) {
102398       {
102399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102400       };
102401     }
102402   }
102403
102404   //Typemap argout in c++ file.
102405   //This will convert c++ string to c# string
102406   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102407 }
102408
102409
102410 //for PixelBuffer and ImageLoading
102411
102412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102413     return (Dali::BaseHandle *)jarg1;
102414 }
102415
102416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102417   void * jresult ;
102418   unsigned int arg1 ;
102419   unsigned int arg2 ;
102420   Dali::Pixel::Format arg3 ;
102421   Dali::Devel::PixelBuffer result;
102422
102423   arg1 = (unsigned int)jarg1;
102424   arg2 = (unsigned int)jarg2;
102425   arg3 = (Dali::Pixel::Format)jarg3;
102426   {
102427     try {
102428       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102429     } catch (std::out_of_range& e) {
102430       {
102431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102432       };
102433     } catch (std::exception& e) {
102434       {
102435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102436       };
102437     } catch (...) {
102438       {
102439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102440       };
102441     }
102442   }
102443   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102444   return jresult;
102445 }
102446
102447
102448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102449   void * jresult ;
102450   Dali::Devel::PixelBuffer *result = 0 ;
102451
102452   {
102453     try {
102454       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102455     } catch (std::out_of_range& e) {
102456       {
102457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102458       };
102459     } catch (std::exception& e) {
102460       {
102461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102462       };
102463     } catch (...) {
102464       {
102465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102466       };
102467     }
102468   }
102469   jresult = (void *)result;
102470   return jresult;
102471 }
102472
102473
102474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102475   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102476
102477   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102478   {
102479     try {
102480       delete arg1;
102481     } catch (std::out_of_range& e) {
102482       {
102483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102484       };
102485     } catch (std::exception& e) {
102486       {
102487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102488       };
102489     } catch (...) {
102490       {
102491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102492       };
102493     }
102494   }
102495 }
102496
102497
102498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102499   void * jresult ;
102500   Dali::Devel::PixelBuffer *arg1 = 0 ;
102501   Dali::Devel::PixelBuffer *result = 0 ;
102502
102503   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102504   if (!arg1) {
102505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102506     return 0;
102507   }
102508   {
102509     try {
102510       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102511     } catch (std::out_of_range& e) {
102512       {
102513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102514       };
102515     } catch (std::exception& e) {
102516       {
102517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102518       };
102519     } catch (...) {
102520       {
102521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102522       };
102523     }
102524   }
102525   jresult = (void *)result;
102526   return jresult;
102527 }
102528
102529
102530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102531   void * jresult ;
102532   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102533   Dali::Devel::PixelBuffer *arg2 = 0 ;
102534   Dali::Devel::PixelBuffer *result = 0 ;
102535
102536   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102537   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102538   if (!arg2) {
102539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102540     return 0;
102541   }
102542   {
102543     try {
102544       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102545     } catch (std::out_of_range& e) {
102546       {
102547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102548       };
102549     } catch (std::exception& e) {
102550       {
102551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102552       };
102553     } catch (...) {
102554       {
102555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102556       };
102557     }
102558   }
102559   jresult = (void *)result;
102560   return jresult;
102561 }
102562
102563
102564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102565   void * jresult ;
102566   Dali::Devel::PixelBuffer *arg1 = 0 ;
102567   Dali::PixelData result;
102568
102569   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102570   if (!arg1) {
102571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102572     return 0;
102573   }
102574   {
102575     try {
102576       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102577     } catch (std::out_of_range& e) {
102578       {
102579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102580       };
102581     } catch (std::exception& e) {
102582       {
102583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102584       };
102585     } catch (...) {
102586       {
102587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102588       };
102589     }
102590   }
102591   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102592   return jresult;
102593 }
102594
102595
102596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102597   void * jresult ;
102598   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102599   Dali::PixelData result;
102600
102601   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102602   {
102603     try {
102604       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102605     } catch (std::out_of_range& e) {
102606       {
102607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102608       };
102609     } catch (std::exception& e) {
102610       {
102611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102612       };
102613     } catch (...) {
102614       {
102615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102616       };
102617     }
102618   }
102619   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102620   return jresult;
102621 }
102622
102623
102624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102625   void * jresult ;
102626   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102627   unsigned char *result = 0 ;
102628
102629   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102630   {
102631     try {
102632       result = (unsigned char *)(arg1)->GetBuffer();
102633     } catch (std::out_of_range& e) {
102634       {
102635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102636       };
102637     } catch (std::exception& e) {
102638       {
102639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102640       };
102641     } catch (...) {
102642       {
102643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102644       };
102645     }
102646   }
102647   jresult = (void *)result;
102648   return jresult;
102649 }
102650
102651
102652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102653   unsigned int jresult ;
102654   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102655   unsigned int result;
102656
102657   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102658   {
102659     try {
102660       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102661     } catch (std::out_of_range& e) {
102662       {
102663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102664       };
102665     } catch (std::exception& e) {
102666       {
102667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102668       };
102669     } catch (...) {
102670       {
102671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102672       };
102673     }
102674   }
102675   jresult = result;
102676   return jresult;
102677 }
102678
102679
102680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102681   unsigned int jresult ;
102682   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102683   unsigned int result;
102684
102685   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102686   {
102687     try {
102688       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102689     } catch (std::out_of_range& e) {
102690       {
102691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102692       };
102693     } catch (std::exception& e) {
102694       {
102695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102696       };
102697     } catch (...) {
102698       {
102699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102700       };
102701     }
102702   }
102703   jresult = result;
102704   return jresult;
102705 }
102706
102707
102708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102709   int jresult ;
102710   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102711   Dali::Pixel::Format result;
102712
102713   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102714   {
102715     try {
102716       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102717     } catch (std::out_of_range& e) {
102718       {
102719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102720       };
102721     } catch (std::exception& e) {
102722       {
102723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102724       };
102725     } catch (...) {
102726       {
102727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102728       };
102729     }
102730   }
102731   jresult = (int)result;
102732   return jresult;
102733 }
102734
102735
102736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102737   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102738   Dali::Devel::PixelBuffer arg2 ;
102739   float arg3 ;
102740   bool arg4 ;
102741   Dali::Devel::PixelBuffer *argp2 ;
102742
102743   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102744   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102745   if (!argp2) {
102746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102747     return ;
102748   }
102749   arg2 = *argp2;
102750   arg3 = (float)jarg3;
102751   arg4 = jarg4 ? true : false;
102752   {
102753     try {
102754       (arg1)->ApplyMask(arg2,arg3,arg4);
102755     } catch (std::out_of_range& e) {
102756       {
102757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102758       };
102759     } catch (std::exception& e) {
102760       {
102761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102762       };
102763     } catch (...) {
102764       {
102765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102766       };
102767     }
102768   }
102769 }
102770
102771
102772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102773   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102774   Dali::Devel::PixelBuffer arg2 ;
102775   float arg3 ;
102776   Dali::Devel::PixelBuffer *argp2 ;
102777
102778   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102779   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102780   if (!argp2) {
102781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102782     return ;
102783   }
102784   arg2 = *argp2;
102785   arg3 = (float)jarg3;
102786   {
102787     try {
102788       (arg1)->ApplyMask(arg2,arg3);
102789     } catch (std::out_of_range& e) {
102790       {
102791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102792       };
102793     } catch (std::exception& e) {
102794       {
102795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102796       };
102797     } catch (...) {
102798       {
102799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102800       };
102801     }
102802   }
102803 }
102804
102805
102806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102807   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102808   Dali::Devel::PixelBuffer arg2 ;
102809   Dali::Devel::PixelBuffer *argp2 ;
102810
102811   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102812   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102813   if (!argp2) {
102814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102815     return ;
102816   }
102817   arg2 = *argp2;
102818   {
102819     try {
102820       (arg1)->ApplyMask(arg2);
102821     } catch (std::out_of_range& e) {
102822       {
102823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102824       };
102825     } catch (std::exception& e) {
102826       {
102827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102828       };
102829     } catch (...) {
102830       {
102831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102832       };
102833     }
102834   }
102835 }
102836
102837
102838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102839   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102840   float arg2 ;
102841
102842   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102843   arg2 = (float)jarg2;
102844   {
102845     try {
102846       (arg1)->ApplyGaussianBlur(arg2);
102847     } catch (std::out_of_range& e) {
102848       {
102849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102850       };
102851     } catch (std::exception& e) {
102852       {
102853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102854       };
102855     } catch (...) {
102856       {
102857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102858       };
102859     }
102860   }
102861 }
102862
102863
102864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102865   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102866   uint16_t arg2 ;
102867   uint16_t arg3 ;
102868   uint16_t arg4 ;
102869   uint16_t arg5 ;
102870
102871   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102872   arg2 = (uint16_t)jarg2;
102873   arg3 = (uint16_t)jarg3;
102874   arg4 = (uint16_t)jarg4;
102875   arg5 = (uint16_t)jarg5;
102876   {
102877     try {
102878       (arg1)->Crop(arg2,arg3,arg4,arg5);
102879     } catch (std::out_of_range& e) {
102880       {
102881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102882       };
102883     } catch (std::exception& e) {
102884       {
102885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102886       };
102887     } catch (...) {
102888       {
102889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102890       };
102891     }
102892   }
102893 }
102894
102895
102896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102897   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102898   uint16_t arg2 ;
102899   uint16_t arg3 ;
102900
102901   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102902   arg2 = (uint16_t)jarg2;
102903   arg3 = (uint16_t)jarg3;
102904   {
102905     try {
102906       (arg1)->Resize(arg2,arg3);
102907     } catch (std::out_of_range& e) {
102908       {
102909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102910       };
102911     } catch (std::exception& e) {
102912       {
102913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102914       };
102915     } catch (...) {
102916       {
102917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102918       };
102919     }
102920   }
102921 }
102922
102923
102924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102925   void * jresult ;
102926   std::string *arg1 = 0 ;
102927   Dali::ImageDimensions arg2 ;
102928   Dali::FittingMode::Type arg3 ;
102929   Dali::SamplingMode::Type arg4 ;
102930   bool arg5 ;
102931   Dali::ImageDimensions *argp2 ;
102932   Dali::Devel::PixelBuffer result;
102933
102934   if (!jarg1) {
102935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102936     return 0;
102937   }
102938   std::string arg1_str(jarg1);
102939   arg1 = &arg1_str;
102940   argp2 = (Dali::ImageDimensions *)jarg2;
102941   if (!argp2) {
102942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102943     return 0;
102944   }
102945   arg2 = *argp2;
102946   arg3 = (Dali::FittingMode::Type)jarg3;
102947   arg4 = (Dali::SamplingMode::Type)jarg4;
102948   arg5 = jarg5 ? true : false;
102949   {
102950     try {
102951       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102952     } catch (std::out_of_range& e) {
102953       {
102954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102955       };
102956     } catch (std::exception& e) {
102957       {
102958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102959       };
102960     } catch (...) {
102961       {
102962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102963       };
102964     }
102965   }
102966   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102967
102968   return jresult;
102969 }
102970
102971
102972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102973   void * jresult ;
102974   std::string *arg1 = 0 ;
102975   Dali::ImageDimensions arg2 ;
102976   Dali::FittingMode::Type arg3 ;
102977   Dali::SamplingMode::Type arg4 ;
102978   Dali::ImageDimensions *argp2 ;
102979   Dali::Devel::PixelBuffer result;
102980
102981   if (!jarg1) {
102982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102983     return 0;
102984   }
102985   std::string arg1_str(jarg1);
102986   arg1 = &arg1_str;
102987   argp2 = (Dali::ImageDimensions *)jarg2;
102988   if (!argp2) {
102989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102990     return 0;
102991   }
102992   arg2 = *argp2;
102993   arg3 = (Dali::FittingMode::Type)jarg3;
102994   arg4 = (Dali::SamplingMode::Type)jarg4;
102995   {
102996     try {
102997       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102998     } catch (std::out_of_range& e) {
102999       {
103000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103001       };
103002     } catch (std::exception& e) {
103003       {
103004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103005       };
103006     } catch (...) {
103007       {
103008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103009       };
103010     }
103011   }
103012   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103013
103014   return jresult;
103015 }
103016
103017
103018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103019   void * jresult ;
103020   std::string *arg1 = 0 ;
103021   Dali::ImageDimensions arg2 ;
103022   Dali::FittingMode::Type arg3 ;
103023   Dali::ImageDimensions *argp2 ;
103024   Dali::Devel::PixelBuffer result;
103025
103026   if (!jarg1) {
103027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103028     return 0;
103029   }
103030   std::string arg1_str(jarg1);
103031   arg1 = &arg1_str;
103032   argp2 = (Dali::ImageDimensions *)jarg2;
103033   if (!argp2) {
103034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103035     return 0;
103036   }
103037   arg2 = *argp2;
103038   arg3 = (Dali::FittingMode::Type)jarg3;
103039   {
103040     try {
103041       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103042     } catch (std::out_of_range& e) {
103043       {
103044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103045       };
103046     } catch (std::exception& e) {
103047       {
103048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103049       };
103050     } catch (...) {
103051       {
103052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103053       };
103054     }
103055   }
103056   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103057
103058   return jresult;
103059 }
103060
103061
103062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103063   void * jresult ;
103064   std::string *arg1 = 0 ;
103065   Dali::ImageDimensions arg2 ;
103066   Dali::ImageDimensions *argp2 ;
103067   Dali::Devel::PixelBuffer result;
103068
103069   if (!jarg1) {
103070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103071     return 0;
103072   }
103073   std::string arg1_str(jarg1);
103074   arg1 = &arg1_str;
103075   argp2 = (Dali::ImageDimensions *)jarg2;
103076   if (!argp2) {
103077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103078     return 0;
103079   }
103080   arg2 = *argp2;
103081   {
103082     try {
103083       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103084     } catch (std::out_of_range& e) {
103085       {
103086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103087       };
103088     } catch (std::exception& e) {
103089       {
103090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103091       };
103092     } catch (...) {
103093       {
103094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103095       };
103096     }
103097   }
103098   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103099
103100   return jresult;
103101 }
103102
103103
103104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103105   void * jresult ;
103106   std::string *arg1 = 0 ;
103107   Dali::Devel::PixelBuffer result;
103108
103109   if (!jarg1) {
103110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103111     return 0;
103112   }
103113   std::string arg1_str(jarg1);
103114   arg1 = &arg1_str;
103115   {
103116     try {
103117       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103118     } catch (std::out_of_range& e) {
103119       {
103120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103121       };
103122     } catch (std::exception& e) {
103123       {
103124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103125       };
103126     } catch (...) {
103127       {
103128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103129       };
103130     }
103131   }
103132   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103133
103134   return jresult;
103135 }
103136
103137
103138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103139   void * jresult ;
103140   std::string *arg1 = 0 ;
103141   Dali::ImageDimensions arg2 ;
103142   Dali::FittingMode::Type arg3 ;
103143   Dali::SamplingMode::Type arg4 ;
103144   bool arg5 ;
103145   Dali::ImageDimensions *argp2 ;
103146   Dali::ImageDimensions result;
103147
103148   if (!jarg1) {
103149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103150     return 0;
103151   }
103152   std::string arg1_str(jarg1);
103153   arg1 = &arg1_str;
103154   argp2 = (Dali::ImageDimensions *)jarg2;
103155   if (!argp2) {
103156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103157     return 0;
103158   }
103159   arg2 = *argp2;
103160   arg3 = (Dali::FittingMode::Type)jarg3;
103161   arg4 = (Dali::SamplingMode::Type)jarg4;
103162   arg5 = jarg5 ? true : false;
103163   {
103164     try {
103165       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103166     } catch (std::out_of_range& e) {
103167       {
103168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103169       };
103170     } catch (std::exception& e) {
103171       {
103172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103173       };
103174     } catch (...) {
103175       {
103176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103177       };
103178     }
103179   }
103180   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103181
103182   return jresult;
103183 }
103184
103185
103186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103187   void * jresult ;
103188   std::string *arg1 = 0 ;
103189   Dali::ImageDimensions arg2 ;
103190   Dali::FittingMode::Type arg3 ;
103191   Dali::SamplingMode::Type arg4 ;
103192   Dali::ImageDimensions *argp2 ;
103193   Dali::ImageDimensions result;
103194
103195   if (!jarg1) {
103196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103197     return 0;
103198   }
103199   std::string arg1_str(jarg1);
103200   arg1 = &arg1_str;
103201   argp2 = (Dali::ImageDimensions *)jarg2;
103202   if (!argp2) {
103203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103204     return 0;
103205   }
103206   arg2 = *argp2;
103207   arg3 = (Dali::FittingMode::Type)jarg3;
103208   arg4 = (Dali::SamplingMode::Type)jarg4;
103209   {
103210     try {
103211       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103212     } catch (std::out_of_range& e) {
103213       {
103214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103215       };
103216     } catch (std::exception& e) {
103217       {
103218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103219       };
103220     } catch (...) {
103221       {
103222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103223       };
103224     }
103225   }
103226   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103227
103228   return jresult;
103229 }
103230
103231
103232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103233   void * jresult ;
103234   std::string *arg1 = 0 ;
103235   Dali::ImageDimensions arg2 ;
103236   Dali::FittingMode::Type arg3 ;
103237   Dali::ImageDimensions *argp2 ;
103238   Dali::ImageDimensions result;
103239
103240   if (!jarg1) {
103241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103242     return 0;
103243   }
103244   std::string arg1_str(jarg1);
103245   arg1 = &arg1_str;
103246   argp2 = (Dali::ImageDimensions *)jarg2;
103247   if (!argp2) {
103248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103249     return 0;
103250   }
103251   arg2 = *argp2;
103252   arg3 = (Dali::FittingMode::Type)jarg3;
103253   {
103254     try {
103255       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103256     } catch (std::out_of_range& e) {
103257       {
103258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103259       };
103260     } catch (std::exception& e) {
103261       {
103262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103263       };
103264     } catch (...) {
103265       {
103266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103267       };
103268     }
103269   }
103270   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103271
103272   return jresult;
103273 }
103274
103275
103276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103277   void * jresult ;
103278   std::string *arg1 = 0 ;
103279   Dali::ImageDimensions arg2 ;
103280   Dali::ImageDimensions *argp2 ;
103281   Dali::ImageDimensions result;
103282
103283   if (!jarg1) {
103284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103285     return 0;
103286   }
103287   std::string arg1_str(jarg1);
103288   arg1 = &arg1_str;
103289   argp2 = (Dali::ImageDimensions *)jarg2;
103290   if (!argp2) {
103291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103292     return 0;
103293   }
103294   arg2 = *argp2;
103295   {
103296     try {
103297       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103298     } catch (std::out_of_range& e) {
103299       {
103300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103301       };
103302     } catch (std::exception& e) {
103303       {
103304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103305       };
103306     } catch (...) {
103307       {
103308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103309       };
103310     }
103311   }
103312   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103313
103314   return jresult;
103315 }
103316
103317
103318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103319   void * jresult ;
103320   std::string *arg1 = 0 ;
103321   Dali::ImageDimensions result;
103322
103323   if (!jarg1) {
103324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103325     return 0;
103326   }
103327   std::string arg1_str(jarg1);
103328   arg1 = &arg1_str;
103329   {
103330     try {
103331       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103332     } catch (std::out_of_range& e) {
103333       {
103334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103335       };
103336     } catch (std::exception& e) {
103337       {
103338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103339       };
103340     } catch (...) {
103341       {
103342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103343       };
103344     }
103345   }
103346   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103347
103348   return jresult;
103349 }
103350
103351
103352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103353   void * jresult ;
103354   std::string *arg1 = 0 ;
103355   Dali::ImageDimensions arg2 ;
103356   Dali::FittingMode::Type arg3 ;
103357   Dali::SamplingMode::Type arg4 ;
103358   bool arg5 ;
103359   Dali::ImageDimensions *argp2 ;
103360   Dali::Devel::PixelBuffer result;
103361
103362   if (!jarg1) {
103363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103364     return 0;
103365   }
103366   std::string arg1_str(jarg1);
103367   arg1 = &arg1_str;
103368   argp2 = (Dali::ImageDimensions *)jarg2;
103369   if (!argp2) {
103370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103371     return 0;
103372   }
103373   arg2 = *argp2;
103374   arg3 = (Dali::FittingMode::Type)jarg3;
103375   arg4 = (Dali::SamplingMode::Type)jarg4;
103376   arg5 = jarg5 ? true : false;
103377   {
103378     try {
103379       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103380     } catch (std::out_of_range& e) {
103381       {
103382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103383       };
103384     } catch (std::exception& e) {
103385       {
103386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103387       };
103388     } catch (...) {
103389       {
103390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103391       };
103392     }
103393   }
103394   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103395
103396   return jresult;
103397 }
103398
103399
103400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103401   void * jresult ;
103402   std::string *arg1 = 0 ;
103403   Dali::ImageDimensions arg2 ;
103404   Dali::FittingMode::Type arg3 ;
103405   Dali::SamplingMode::Type arg4 ;
103406   Dali::ImageDimensions *argp2 ;
103407   Dali::Devel::PixelBuffer result;
103408
103409   if (!jarg1) {
103410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103411     return 0;
103412   }
103413   std::string arg1_str(jarg1);
103414   arg1 = &arg1_str;
103415   argp2 = (Dali::ImageDimensions *)jarg2;
103416   if (!argp2) {
103417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103418     return 0;
103419   }
103420   arg2 = *argp2;
103421   arg3 = (Dali::FittingMode::Type)jarg3;
103422   arg4 = (Dali::SamplingMode::Type)jarg4;
103423   {
103424     try {
103425       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103426     } catch (std::out_of_range& e) {
103427       {
103428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103429       };
103430     } catch (std::exception& e) {
103431       {
103432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103433       };
103434     } catch (...) {
103435       {
103436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103437       };
103438     }
103439   }
103440   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103441
103442   return jresult;
103443 }
103444
103445
103446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103447   void * jresult ;
103448   std::string *arg1 = 0 ;
103449   Dali::ImageDimensions arg2 ;
103450   Dali::FittingMode::Type arg3 ;
103451   Dali::ImageDimensions *argp2 ;
103452   Dali::Devel::PixelBuffer result;
103453
103454   if (!jarg1) {
103455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103456     return 0;
103457   }
103458   std::string arg1_str(jarg1);
103459   arg1 = &arg1_str;
103460   argp2 = (Dali::ImageDimensions *)jarg2;
103461   if (!argp2) {
103462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103463     return 0;
103464   }
103465   arg2 = *argp2;
103466   arg3 = (Dali::FittingMode::Type)jarg3;
103467   {
103468     try {
103469       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103470     } catch (std::out_of_range& e) {
103471       {
103472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103473       };
103474     } catch (std::exception& e) {
103475       {
103476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103477       };
103478     } catch (...) {
103479       {
103480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103481       };
103482     }
103483   }
103484   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103485
103486   return jresult;
103487 }
103488
103489
103490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103491   void * jresult ;
103492   std::string *arg1 = 0 ;
103493   Dali::ImageDimensions arg2 ;
103494   Dali::ImageDimensions *argp2 ;
103495   Dali::Devel::PixelBuffer result;
103496
103497   if (!jarg1) {
103498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103499     return 0;
103500   }
103501   std::string arg1_str(jarg1);
103502   arg1 = &arg1_str;
103503   argp2 = (Dali::ImageDimensions *)jarg2;
103504   if (!argp2) {
103505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103506     return 0;
103507   }
103508   arg2 = *argp2;
103509   {
103510     try {
103511       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103512     } catch (std::out_of_range& e) {
103513       {
103514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103515       };
103516     } catch (std::exception& e) {
103517       {
103518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103519       };
103520     } catch (...) {
103521       {
103522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103523       };
103524     }
103525   }
103526   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103527
103528   return jresult;
103529 }
103530
103531
103532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103533   void * jresult ;
103534   std::string *arg1 = 0 ;
103535   Dali::Devel::PixelBuffer result;
103536
103537   if (!jarg1) {
103538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103539     return 0;
103540   }
103541   std::string arg1_str(jarg1);
103542   arg1 = &arg1_str;
103543   {
103544     try {
103545       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103546     } catch (std::out_of_range& e) {
103547       {
103548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103549       };
103550     } catch (std::exception& e) {
103551       {
103552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103553       };
103554     } catch (...) {
103555       {
103556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103557       };
103558     }
103559   }
103560   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103561
103562   return jresult;
103563 }
103564
103565
103566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
103567   unsigned int arg1 ;
103568
103569   arg1 = (unsigned int)jarg1;
103570   {
103571     try {
103572       Dali::SetMaxTextureSize(arg1);
103573     } catch (std::out_of_range& e) {
103574       {
103575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103576       };
103577     } catch (std::exception& e) {
103578       {
103579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103580       };
103581     } catch (...) {
103582       {
103583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103584       };
103585     }
103586   }
103587 }
103588
103589
103590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
103591   unsigned int jresult ;
103592   unsigned int result;
103593
103594   {
103595     try {
103596       result = (unsigned int)Dali::GetMaxTextureSize();
103597     } catch (std::out_of_range& e) {
103598       {
103599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103600       };
103601     } catch (std::exception& e) {
103602       {
103603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103604       };
103605     } catch (...) {
103606       {
103607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103608       };
103609     }
103610   }
103611   jresult = result;
103612   return jresult;
103613 }
103614
103615
103616 #ifdef __cplusplus
103617 }
103618 #endif
103619